[netcdf4-python] 01/09: Imported Upstream version 1.2.4
Sebastiaan Couwenberg
sebastic at moszumanska.debian.org
Sat Apr 16 15:52:00 UTC 2016
This is an automated email from the git hooks/post-receive script.
sebastic pushed a commit to branch master
in repository netcdf4-python.
commit 5dba62623e6e2a9432972f01334e72900343e5d0
Author: Bas Couwenberg <sebastic at xs4all.nl>
Date: Sat Apr 16 17:09:53 2016 +0200
Imported Upstream version 1.2.4
---
Changelog | 15 +
MANIFEST.in | 3 +
README.md | 9 +-
appveyor.yml | 72 +
conda.recipe/bld.bat | 12 +
conda.recipe/build.sh | 10 +
conda.recipe/meta.yaml | 44 +
conda.recipe/run_test.py | 14 +
docs/netCDF4/index.html | 120 +-
netCDF4/_netCDF4.c | 23434 +++++++++++++++++++--------------------
netCDF4/_netCDF4.pyx | 108 +-
setup.py | 2 +-
test/tst_atts.py | 34 +-
test/tst_cdf5.py | 2 +-
test/tst_compound_alignment.py | 2 +-
test/tst_compoundatt.py | 2 +-
test/tst_compoundvar.py | 2 +-
test/tst_compression.py | 2 +-
test/tst_dims.py | 2 +-
test/tst_diskless.py | 4 +-
test/tst_endian.py | 43 +-
test/tst_enum.py | 2 +-
test/tst_fancyslicing.py | 2 +-
test/tst_grps.py | 4 +-
test/tst_grps2.py | 2 +-
test/tst_masked.py | 2 +-
test/tst_masked2.py | 6 +-
test/tst_masked3.py | 4 +-
test/tst_multifile.py | 4 +-
test/tst_multifile2.py | 4 +-
test/tst_netcdftime.py | 2 +-
test/tst_refcount.py | 2 +-
test/tst_rename.py | 2 +-
test/tst_scalarvar.py | 2 +-
test/tst_scaled.py | 4 +-
test/tst_shape.py | 2 +-
test/tst_slicing.py | 2 +-
test/tst_types.py | 2 +-
test/tst_unicode.py | 2 +-
test/tst_unicode3.py | 2 +-
test/tst_unlimdim.py | 2 +-
test/tst_vars.py | 2 +-
test/tst_vlen.py | 2 +-
43 files changed, 11804 insertions(+), 12190 deletions(-)
diff --git a/Changelog b/Changelog
index 5c6af7b..b0ab062 100644
--- a/Changelog
+++ b/Changelog
@@ -1,3 +1,18 @@
+ version 1.2.4 (tag v1.2.4rel)
+==============================
+ * Fix for issue #554. It is now ensured that data is in native endian
+ byte order before passing to netcdf-c library. Data read from variable
+ with non-native byte order is also byte-swapped, so that dtype remains
+ consistent with netcdf variable. Behavior now consistent with h5py.
+ * raise warning for HDF5 1.10.x (issue #549), since backwards
+ incompatible files may be created.
+ * raise AttributeError instead of RuntimeError when attribute operation
+ fails. raise IOError instead of RuntimeError when nc_create or
+ nc_open fails (issue #546).
+ * Use NamedTemporaryFile instead of deprecated mktemp in tests
+ (pull request #543).
+ * add AppVeyor automated windows tests (pull request #540).
+
version 1.2.3.1 (tag v1.2.3.1rel)
==================================
* fix bug in setup.py (pull request #539, introduced in issue #518).
diff --git a/MANIFEST.in b/MANIFEST.in
index e803561..a14727f 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,10 +1,13 @@
recursive-include docs *
recursive-include man *
recursive-include include *
+recursive-include conda.recipe
include MANIFEST.in
include README.md
include COPYING
include Changelog
+include appveyor.yml
+include .travis.yml
include setup.cfg
include setup.cfg.template
include examples/*py
diff --git a/README.md b/README.md
index 55bd7ea..190e5a4 100644
--- a/README.md
+++ b/README.md
@@ -1,12 +1,19 @@
# netcdf4-python
[Python](http://python.org)/[numpy](http://numpy.org) interface to the netCDF [C library](https://github.com/Unidata/netcdf-c).
-[](https://travis-ci.org/Unidata/netcdf4-python)
+[](https://travis-ci.org/Unidata/netcdf4-python)
+[](https://ci.appveyor.com/project/jswhit/netcdf4-python/branch/master)
[](http://python.org/pypi/netCDF4)
## News
For the latest updates, see the [Changelog](https://github.com/Unidata/netcdf4-python/blob/master/Changelog).
+4/11/2016: Version [1.2.4](https://pypi.python.org/pypi/netCDF4/1.2.4) released.
+Bugs in handling of variables with specified non-native "endian-ness" (byte-order) fixed ([issue #554]
+(https://github.com/Unidata/netcdf4-python/issues/554)). Build instructions updated and warning issued
+to deal with potential backwards incompatibility introduced when using HDF5 1.10.x
+(see [Unidata/netcdf-c/issue#250](https://github.com/Unidata/netcdf-c/issues/250)).
+
3/10/2016: Version [1.2.3](https://pypi.python.org/pypi/netCDF4/1.2.3) released. Various bug fixes.
All text attributes in ``NETCDF4`` formatted files are now written as type ``NC_CHAR``, unless they contain unicode characters that
cannot be encoded in ascii, in which case they are written as ``NC_STRING``. Previously,
diff --git a/appveyor.yml b/appveyor.yml
new file mode 100644
index 0000000..2d5a1d6
--- /dev/null
+++ b/appveyor.yml
@@ -0,0 +1,72 @@
+environment:
+
+ CONDA_INSTALL_LOCN: "C:\\conda"
+
+ # SDK v7.0 MSVC Express 2008's SetEnv.cmd script will fail if the
+ # /E:ON and /V:ON options are not enabled in the batch script interpreter
+ # See: http://stackoverflow.com/a/13751649/163740
+ CMD_IN_ENV: "cmd /E:ON /V:ON /C obvci_appveyor_python_build_env.cmd"
+
+ # Workaround for https://github.com/conda/conda-build/issues/636
+ PYTHONIOENCODING: "UTF-8"
+ PYTHONUNBUFFERED: "1"
+
+ # We set a default Python version for the miniconda that is to be installed.
+ # This can be overridden in the matrix definition where appropriate.
+ CONDA_PY: "27"
+
+ matrix:
+ - TARGET_ARCH: x86
+ CONDA_NPY: 110
+ CONDA_PY: 27
+
+ - TARGET_ARCH: x64
+ CONDA_NPY: 110
+ CONDA_PY: 27
+
+ - TARGET_ARCH: x86
+ CONDA_NPY: 110
+ CONDA_PY: 35
+
+ - TARGET_ARCH: x64
+ CONDA_NPY: 110
+ CONDA_PY: 35
+
+platform:
+ - x64
+
+install:
+ # If there is a newer build queued for the same PR, cancel this one.
+ # The AppVeyor 'rollout builds' option is supposed to serve the same
+ # purpose but it is problematic because it tends to cancel builds pushed
+ # directly to master instead of just PR builds (or the converse).
+ # credits: JuliaLang developers.
+ - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
+ https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
+ Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
+ throw "There are newer queued builds for this pull request, failing early." }
+
+ # Set the CONDA_NPY, although it has no impact on the actual build.
+ # We need this because of a test within conda-build.
+ - cmd: set CONDA_NPY=19
+
+ # Use the pre-installed Miniconda for the desired arch.
+ - ps: if($env:TARGET_ARCH -eq 'x86')
+ {$root = "C:\Miniconda"}
+ else
+ {$root = "C:\Miniconda-x64"}
+ $env:path="$root;$root\Scripts;$root\Library\bin;$($env:path)"
+
+ # Update conda.
+ - cmd: conda update --yes --quiet conda
+
+ # Conda build tools.
+ - cmd: conda install --yes --quiet obvious-ci --channel conda-forge
+ - cmd: obvci_install_conda_build_tools.py
+ - cmd: conda info
+
+# Skip .NET project specific build phase.
+build: off
+
+test_script:
+ - "%CMD_IN_ENV% conda build conda.recipe --quiet"
diff --git a/conda.recipe/bld.bat b/conda.recipe/bld.bat
new file mode 100644
index 0000000..e557907
--- /dev/null
+++ b/conda.recipe/bld.bat
@@ -0,0 +1,12 @@
+set SITECFG=%SRC_DIR%/setup.cfg
+
+echo [options] > %SITECFG%
+echo use_cython=True >> %SITECFG%
+echo [directories] >> %SITECFG%
+echo HDF5_libdir = %LIBRARY_LIB% >> %SITECFG%
+echo HDF5_incdir = %LIBRARY_INC% >> %SITECFG%
+echo netCDF4_libdir = %LIBRARY_LIB% >> %SITECFG%
+echo netCDF4_incdir = %LIBRARY_INC% >> %SITECFG%
+
+"%PYTHON%" setup.py install --single-version-externally-managed --record record.txt
+if errorlevel 1 exit 1
diff --git a/conda.recipe/build.sh b/conda.recipe/build.sh
new file mode 100644
index 0000000..582d71c
--- /dev/null
+++ b/conda.recipe/build.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+SETUPCFG=$SRC_DIR\setup.cfg
+
+echo "[options]" > $SETUPCFG
+echo "use_cython=True" >> $SETUPCFG
+echo "[directories]" >> $SETUPCFG
+echo "netCDF4_dir = $PREFIX" >> $SETUPCFG
+
+${PYTHON} setup.py install --single-version-externally-managed --record record.txt
diff --git a/conda.recipe/meta.yaml b/conda.recipe/meta.yaml
new file mode 100644
index 0000000..23a706c
--- /dev/null
+++ b/conda.recipe/meta.yaml
@@ -0,0 +1,44 @@
+{% set version = "dev" %}
+
+package:
+ name: netcdf4
+ version: {{ version }}
+
+source:
+ path: ../
+
+build:
+ number: 0
+ entry_points:
+ - ncinfo = netCDF4.utils:ncinfo
+ - nc4tonc3 = netCDF4.utils:nc4tonc3
+ - nc3tonc4 = netCDF4.utils:nc3tonc4
+
+requirements:
+ build:
+ - python
+ - setuptools
+ - numpy x.x
+ - cython
+ - hdf5
+ - libnetcdf
+ run:
+ - python
+ - setuptools
+ - numpy x.x
+ - hdf5
+ - libnetcdf
+
+test:
+ imports:
+ - netCDF4
+ - netcdftime
+ commands:
+ - ncinfo -h
+ - nc4tonc3 -h
+ - nc3tonc4 -h
+
+about:
+ home: http://github.com/Unidata/netcdf4-python
+ license: OSI Approved
+ summary: Provides an object-oriented python interface to the netCDF version 4 library.
diff --git a/conda.recipe/run_test.py b/conda.recipe/run_test.py
new file mode 100644
index 0000000..d59fda9
--- /dev/null
+++ b/conda.recipe/run_test.py
@@ -0,0 +1,14 @@
+import os
+import netCDF4
+
+# Check OPeNDAP functionality.
+url = 'http://geoport-dev.whoi.edu/thredds/dodsC/estofs/atlantic'
+nc = netCDF4.Dataset(url)
+
+# Check if it was compiled with cython.
+assert nc.filepath() == url
+
+# Run the unittests.
+test_dir = os.path.join(os.environ['SRC_DIR'], 'test')
+os.chdir(test_dir)
+os.system('python run_all.py')
diff --git a/docs/netCDF4/index.html b/docs/netCDF4/index.html
index e324e1b..1e3d4de 100644
--- a/docs/netCDF4/index.html
+++ b/docs/netCDF4/index.html
@@ -4,7 +4,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
<title>netCDF4 API documentation</title>
- <meta name="description" content="Version 1.2.3
+ <meta name="description" content="Version 1.2.4
-------------
- - -
@@ -865,6 +865,7 @@ table {
.codehilite .err { border: 1px solid #FF0000 } /* Error */
.codehilite .k { color: #008000; font-weight: bold } /* Keyword */
.codehilite .o { color: #666666 } /* Operator */
+.codehilite .ch { color: #408080; font-style: italic } /* Comment.Hashbang */
.codehilite .cm { color: #408080; font-style: italic } /* Comment.Multiline */
.codehilite .cp { color: #BC7A00 } /* Comment.Preproc */
.codehilite .c1 { color: #408080; font-style: italic } /* Comment.Single */
@@ -1255,7 +1256,7 @@ table {
<header id="section-intro">
<h1 class="title"><span class="name">netCDF4</span> module</h1>
- <h2>Version 1.2.3</h2>
+ <h2>Version 1.2.4</h2>
<hr />
<h1>Introduction</h1>
<p>netcdf4-python is a Python interface to the netCDF C library. </p>
@@ -1292,8 +1293,11 @@ types) are not supported.</p>
will be disabled to preserve backward compatibility with older versions of the netCDF
library.</li>
<li>For python < 2.7, the <a href="http://python.org/pypi/ordereddict">ordereddict module</a>.</li>
-<li>The HDF5 C library version 1.8.4-patch1 or higher (1.8.8 or higher
- recommended) from <a href="ftp://ftp.hdfgroup.org/HDF5/current/src"></a>.
+<li>The HDF5 C library version 1.8.4-patch1 or higher (1.8.x recommended)
+ from <a href="ftp://ftp.hdfgroup.org/HDF5/current/src"></a>.
+ <strong><em>netCDF version 4.4.1 or higher is recommended if using HDF5 1.10.x -
+ otherwise resulting files may be unreadable by clients using earlier
+ versions of HDF5. For netCDF < 4.4.1, HDF5 version 1.8.x is recommended.</em></strong>
Be sure to build with <code>--enable-hl --enable-shared</code>.</li>
<li><a href="http://curl.haxx.se/libcurl">Libcurl</a>, if you want
<a href="http://opendap.org">OPeNDAP</a> support.</li>
@@ -1510,7 +1514,7 @@ The <a href="#netCDF4.Dimension.isunlimited"><code>isunlimited</code></a> method
can be used to determine if the dimensions is unlimited, or appendable.</p>
<div class="codehilite"><pre><span class="o">>>></span> <span class="k">print</span> <span class="nb">len</span><span class="p">(</span><span class="n">lon</span><span class="p">)</span>
<span class="mi">144</span>
-<span class="o">>>></span> <span class="k">print</span> <span class="nb">len</span><span class="o">.</span><span class="n">isunlimited</span><span class="p">()</span>
+<span class="o">>>></span> <span class="k">print</span> <span class="n">lon</span><span class="o">.</span><span class="n">isunlimited</span><span class="p">()</span>
<span class="bp">False</span>
<span class="o">>>></span> <span class="k">print</span> <span class="n">time</span><span class="o">.</span><span class="n">isunlimited</span><span class="p">()</span>
<span class="bp">True</span>
@@ -1567,7 +1571,7 @@ used later to access and set variable data and attributes.</p>
<span class="o">>>></span> <span class="n">levels</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">"level"</span><span class="p">,</span><span class="s">"i4"</span><span class="p">,(</span><span class="s">"level"</span><span class="p">,))</span>
<span class="o">>>></span> <span class="n">latitudes</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">"latitude"</span><span class="p">,</span><span class="s">"f4"</span><span class="p">,(</span><span class="s">"lat"</span><span class="p">,))</span>
<span class="o">>>></span> <span class="n">longitudes</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">"longitude"</span><span class="p">,</span><span class="s">"f4"</span><span class="p">,(</span><span class="s">"lon"</span><span class="p">,))</span>
-<span class="o">>>></span> <span class="c"># two dimensions unlimited</span>
+<span class="o">>>></span> <span class="c1"># two dimensions unlimited</span>
<span class="o">>>></span> <span class="n">temp</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">"temp"</span><span class="p">,</span><span class="s">"f4"</span><span class="p">,(</span><span class="s">"time"</span><span class="p">,</span><span class="s">"level"</span><span class="p">,</span><span class="s">"lat"</spa [...]
</pre></div>
@@ -1591,13 +1595,13 @@ used later to access and set variable data and attributes.</p>
<p>If the intermediate groups do not yet exist, they will be created.</p>
<p>You can also query a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or <a href="#netCDF4.Group"><code>Group</code></a> instance directly to obtain <a href="#netCDF4.Group"><code>Group</code></a> or
<a href="#netCDF4.Variable"><code>Variable</code></a> instances using paths.</p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="k">print</span> <span class="n">rootgrp</span><span class="p">[</span><span class="s">"/forecasts/model1"</span><span class="p">]</span> <span class="c"># a Group instance</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="k">print</span> <span class="n">rootgrp</span><span class="p">[</span><span class="s">"/forecasts/model1"</span><span class="p">]</span> <span class="c1"># a Group instance</span>
<span class="o"><</span><span class="nb">type</span> <span class="s">"netCDF4._netCDF4.Group"</span><span class="o">></span>
<span class="n">group</span> <span class="o">/</span><span class="n">forecasts</span><span class="o">/</span><span class="n">model1</span><span class="p">:</span>
<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span> <span class="n">float32</span> <span class="n">temp</span><span class="p">(</span><span class="n">time</span><span class="p">,</span><span class="n">level</span><span class="p">,</span><span class="n">lat</span><span class="p">,</span><span class="n">lon</span><span class="p">)</span>
<span class="n">groups</span><span class="p">:</span>
-<span class="o">>>></span> <span class="k">print</span> <span class="n">rootgrp</span><span class="p">[</span><span class="s">"/forecasts/model1/temp"</span><span class="p">]</span> <span class="c"># a Variable instance</span>
+<span class="o">>>></span> <span class="k">print</span> <span class="n">rootgrp</span><span class="p">[</span><span class="s">"/forecasts/model1/temp"</span><span class="p">]</span> <span class="c1"># a Variable instance</span>
<span class="o"><</span><span class="nb">type</span> <span class="s">"netCDF4._netCDF4.Variable"</span><span class="o">></span>
<span class="n">float32</span> <span class="n">temp</span><span class="p">(</span><span class="n">time</span><span class="p">,</span> <span class="n">level</span><span class="p">,</span> <span class="n">lat</span><span class="p">,</span> <span class="n">lon</span><span class="p">)</span>
<span class="n">path</span> <span class="o">=</span> <span class="o">/</span><span class="n">forecasts</span><span class="o">/</span><span class="n">model1</span>
@@ -1692,7 +1696,7 @@ into it? You can just treat it like an array and assign data to a slice.</p>
<p>Unlike NumPy's array objects, netCDF <a href="#netCDF4.Variable"><code>Variable</code></a>
objects with unlimited dimensions will grow along those dimensions if you
assign data outside the currently defined range of indices.</p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># append along two unlimited dimensions by assigning to slice.</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># append along two unlimited dimensions by assigning to slice.</span>
<span class="o">>>></span> <span class="n">nlats</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="n">dimensions</span><span class="p">[</span><span class="s">"lat"</span><span class="p">])</span>
<span class="o">>>></span> <span class="n">nlons</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="n">dimensions</span><span class="p">[</span><span class="s">"lon"</span><span class="p">])</span>
<span class="o">>>></span> <span class="k">print</span> <span class="s">"temp shape before adding data = "</span><span class="p">,</span><span class="n">temp</span><span class="o">.</span><span class="n">shape</span>
@@ -1703,7 +1707,7 @@ assign data outside the currently defined range of indices.</p>
<span class="o">>>></span> <span class="k">print</span> <span class="s">"temp shape after adding data = "</span><span class="p">,</span><span class="n">temp</span><span class="o">.</span><span class="n">shape</span>
<span class="n">temp</span> <span class="n">shape</span> <span class="n">after</span> <span class="n">adding</span> <span class="n">data</span> <span class="o">=</span> <span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">73</span><span class="p">,</span> <span class="mi">144</span><span class="p">)</span>
<span class="o">>>></span>
-<span class="o">>>></span> <span class="c"># levels have grown, but no values yet assigned.</span>
+<span class="o">>>></span> <span class="c1"># levels have grown, but no values yet assigned.</span>
<span class="o">>>></span> <span class="k">print</span> <span class="s">"levels shape after adding pressure data = "</span><span class="p">,</span><span class="n">levels</span><span class="o">.</span><span class="n">shape</span>
<span class="n">levels</span> <span class="n">shape</span> <span class="n">after</span> <span class="n">adding</span> <span class="n">pressure</span> <span class="n">data</span> <span class="o">=</span> <span class="p">(</span><span class="mi">10</span><span class="p">,)</span>
</pre></div>
@@ -1712,7 +1716,7 @@ assign data outside the currently defined range of indices.</p>
<p>Note that the size of the levels variable grows when data is appended
along the <code>level</code> dimension of the variable <code>temp</code>, even though no
data has yet been assigned to levels.</p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># now, assign data to levels dimension variable.</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># now, assign data to levels dimension variable.</span>
<span class="o">>>></span> <span class="n">levels</span><span class="p">[:]</span> <span class="o">=</span> <span class="p">[</span><span class="mf">1000.</span><span class="p">,</span><span class="mf">850.</span><span class="p">,</span><span class="mf">700.</span><span class="p">,</span><span class="mf">500.</span><span class="p">,</span><span class="mf">300.</span><span class="p">,</span><span class="mf">250.</span><span class="p">,</span><span class="mf">200.</span><span cla [...]
</pre></div>
@@ -1762,10 +1766,10 @@ metadata standards (such as CF) specify that time should be
measure relative to a fixed date using a certain calendar, with units
specified like <code>hours since YY:MM:DD hh-mm-ss</code>. These units can be
awkward to deal with, without a utility to convert the values to and
-from calendar dates. The functione called <a href="#netCDF4.num2date"><code>num2date</code></a> and <a href="#netCDF4.date2num"><code>date2num</code></a> are
+from calendar dates. The function called <a href="#netCDF4.num2date"><code>num2date</code></a> and <a href="#netCDF4.date2num"><code>date2num</code></a> are
provided with this package to do just that. Here's an example of how they
can be used:</p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># fill in times.</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># fill in times.</span>
<span class="o">>>></span> <span class="kn">from</span> <span class="nn">datetime</span> <span class="kn">import</span> <span class="n">datetime</span><span class="p">,</span> <span class="n">timedelta</span>
<span class="o">>>></span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">num2date</span><span class="p">,</span> <span class="n">date2num</span>
<span class="o">>>></span> <span class="n">dates</span> <span class="o">=</span> <span class="p">[</span><span class="n">datetime</span><span class="p">(</span><span class="mi">2001</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span><span class="o">+</span><span class="n">n</span><span class="o">*</span><span class="n">timedelta</span><span class="p">(</span><span class="n">hours</span><span class="o">= [...]
@@ -1889,30 +1893,30 @@ are created from the corresponding numpy data type using the
Since there is no native complex data type in netcdf, compound types are handy
for storing numpy complex arrays. Here's an example:</p>
<div class="codehilite"><pre><span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">"complex.nc"</span><span class="p">,</span><span class="s">"w"</span><span class="p">)</span>
-<span class="o">>>></span> <span class="n">size</span> <span class="o">=</span> <span class="mi">3</span> <span class="c"># length of 1-d complex array</span>
-<span class="o">>>></span> <span class="c"># create sample complex data.</span>
+<span class="o">>>></span> <span class="n">size</span> <span class="o">=</span> <span class="mi">3</span> <span class="c1"># length of 1-d complex array</span>
+<span class="o">>>></span> <span class="c1"># create sample complex data.</span>
<span class="o">>>></span> <span class="n">datac</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="mi">1j</span><span class="o">*</span><span class="p">(</span><span class="mf">1.</span><span class="o">+</span><span class="n">numpy</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">num [...]
-<span class="o">>>></span> <span class="c"># create complex128 compound data type.</span>
+<span class="o">>>></span> <span class="c1"># create complex128 compound data type.</span>
<span class="o">>>></span> <span class="n">complex128</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">dtype</span><span class="p">([(</span><span class="s">"real"</span><span class="p">,</span><span class="n">numpy</span><span class="o">.</span><span class="n">float64</span><span class="p">),(</span><span class="s">"imag"</span><span class="p">,</span><span class="n">numpy</span><span class="o">.</span><span [...]
<span class="o">>>></span> <span class="n">complex128_t</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createCompoundType</span><span class="p">(</span><span class="n">complex128</span><span class="p">,</span><span class="s">"complex128"</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># create a variable with this data type, write some data to it.</span>
+<span class="o">>>></span> <span class="c1"># create a variable with this data type, write some data to it.</span>
<span class="o">>>></span> <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">"x_dim"</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">v</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">"cmplx_var"</span><span class="p">,</span><span class="n">complex128_t</span><span class="p">,</span><span class="s">"x_dim"</span><span class="p">)</span>
-<span class="o">>>></span> <span class="n">data</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="n">size</span><span class="p">,</span><span class="n">complex128</span><span class="p">)</span> <span class="c"># numpy structured array</span>
+<span class="o">>>></span> <span class="n">data</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="n">size</span><span class="p">,</span><span class="n">complex128</span><span class="p">)</span> <span class="c1"># numpy structured array</span>
<span class="o">>>></span> <span class="n">data</span><span class="p">[</span><span class="s">"real"</span><span class="p">]</span> <span class="o">=</span> <span class="n">datac</span><span class="o">.</span><span class="n">real</span><span class="p">;</span> <span class="n">data</span><span class="p">[</span><span class="s">"imag"</span><span class="p">]</span> <span class="o">=</span> <span class="n">datac</span><span class="o">.</span><span class="n">imag</span>
-<span class="o">>>></span> <span class="n">v</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span> <span class="c"># write numpy structured array to netcdf compound var</span>
-<span class="o">>>></span> <span class="c"># close and reopen the file, check the contents.</span>
+<span class="o">>>></span> <span class="n">v</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span> <span class="c1"># write numpy structured array to netcdf compound var</span>
+<span class="o">>>></span> <span class="c1"># close and reopen the file, check the contents.</span>
<span class="o">>>></span> <span class="n">f</span><span class="o">.</span><span class="n">close</span><span class="p">();</span> <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">"complex.nc"</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">v</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">"cmplx_var"</span><span class="p">]</span>
-<span class="o">>>></span> <span class="n">datain</span> <span class="o">=</span> <span class="n">v</span><span class="p">[:]</span> <span class="c"># read in all the data into a numpy structured array</span>
-<span class="o">>>></span> <span class="c"># create an empty numpy complex array</span>
+<span class="o">>>></span> <span class="n">datain</span> <span class="o">=</span> <span class="n">v</span><span class="p">[:]</span> <span class="c1"># read in all the data into a numpy structured array</span>
+<span class="o">>>></span> <span class="c1"># create an empty numpy complex array</span>
<span class="o">>>></span> <span class="n">datac2</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="n">datain</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span><span class="n">numpy</span><span class="o">.</span><span class="n">complex128</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># .. fill it with contents of structured array.</span>
+<span class="o">>>></span> <span class="c1"># .. fill it with contents of structured array.</span>
<span class="o">>>></span> <span class="n">datac2</span><span class="o">.</span><span class="n">real</span> <span class="o">=</span> <span class="n">datain</span><span class="p">[</span><span class="s">"real"</span><span class="p">];</span> <span class="n">datac2</span><span class="o">.</span><span class="n">imag</span> <span class="o">=</span> <span class="n">datain</span><span class="p">[</span><span class="s">"imag"</span><span class="p">]</span>
-<span class="o">>>></span> <span class="k">print</span> <span class="n">datac</span><span class="o">.</span><span class="n">dtype</span><span class="p">,</span><span class="n">datac</span> <span class="c"># original data</span>
+<span class="o">>>></span> <span class="k">print</span> <span class="n">datac</span><span class="o">.</span><span class="n">dtype</span><span class="p">,</span><span class="n">datac</span> <span class="c1"># original data</span>
<span class="n">complex128</span> <span class="p">[</span> <span class="mf">0.54030231</span><span class="o">+</span><span class="mf">0.84147098j</span> <span class="o">-</span><span class="mf">0.84147098</span><span class="o">+</span><span class="mf">0.54030231j</span> <span class="o">-</span><span class="mf">0.54030231</span><span class="o">-</span><span class="mf">0.84147098j</span><span class="p">]</span>
<span class="o">>>></span>
-<span class="o">>>></span> <span class="k">print</span> <span class="n">datac2</span><span class="o">.</span><span class="n">dtype</span><span class="p">,</span><span class="n">datac2</span> <span class="c"># data from file</span>
+<span class="o">>>></span> <span class="k">print</span> <span class="n">datac2</span><span class="o">.</span><span class="n">dtype</span><span class="p">,</span><span class="n">datac2</span> <span class="c1"># data from file</span>
<span class="n">complex128</span> <span class="p">[</span> <span class="mf">0.54030231</span><span class="o">+</span><span class="mf">0.84147098j</span> <span class="o">-</span><span class="mf">0.84147098</span><span class="o">+</span><span class="mf">0.54030231j</span> <span class="o">-</span><span class="mf">0.54030231</span><span class="o">-</span><span class="mf">0.84147098j</span><span class="p">]</span>
</pre></div>
@@ -2047,12 +2051,12 @@ The base integer data type and a python dictionary describing the allowed
values and their names are used to define an Enum data type using
<a href="#netCDF4.Dataset.createEnumType"><code>createEnumType</code></a>.</p>
<div class="codehilite"><pre><span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">'clouds.nc'</span><span class="p">,</span><span class="s">'w'</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># python dict with allowed values and their names.</span>
+<span class="o">>>></span> <span class="c1"># python dict with allowed values and their names.</span>
<span class="o">>>></span> <span class="n">enum_dict</span> <span class="o">=</span> <span class="p">{</span><span class="s">u'Altocumulus'</span><span class="p">:</span> <span class="mi">7</span><span class="p">,</span> <span class="s">u'Missing'</span><span class="p">:</span> <span class="mi">255</span><span class="p">,</span>
<span class="o">>>></span> <span class="s">u'Stratus'</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s">u'Clear'</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span>
<span class="o">>>></span> <span class="s">u'Nimbostratus'</span><span class="p">:</span> <span class="mi">6</span><span class="p">,</span> <span class="s">u'Cumulus'</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="s">u'Altostratus'</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span>
<span class="o">>>></span> <span class="s">u'Cumulonimbus'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">u'Stratocumulus'</span><span class="p">:</span> <span class="mi">3</span><span class="p">}</span>
-<span class="o">>>></span> <span class="c"># create the Enum type called 'cloud_t'.</span>
+<span class="o">>>></span> <span class="c1"># create the Enum type called 'cloud_t'.</span>
<span class="o">>>></span> <span class="n">cloud_type</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createEnumType</span><span class="p">(</span><span class="n">numpy</span><span class="o">.</span><span class="n">uint8</span><span class="p">,</span><span class="s">'cloud_t'</span><span class="p">,</span><span class="n">enum_dict</span><span class="p">)</span>
<span class="o">>>></span> <span class="k">print</span> <span class="n">cloud_type</span>
<span class="o"><</span><span class="nb">type</span> <span class="s">'netCDF4._netCDF4.EnumType'</span><span class="o">></span><span class="p">:</span> <span class="n">name</span> <span class="o">=</span> <span class="s">'cloud_t'</span><span class="p">,</span>
@@ -2070,17 +2074,17 @@ cloud types in enum_dict. A <code>ValueError</code> will be raised if an attempt
is made to write an integer value not associated with one of the
specified names.</p>
<div class="codehilite"><pre><span class="o">>>></span> <span class="n">time</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">'time'</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># create a 1d variable of type 'cloud_type'.</span>
-<span class="o">>>></span> <span class="c"># The fill_value is set to the 'Missing' named value.</span>
+<span class="o">>>></span> <span class="c1"># create a 1d variable of type 'cloud_type'.</span>
+<span class="o">>>></span> <span class="c1"># The fill_value is set to the 'Missing' named value.</span>
<span class="o">>>></span> <span class="n">cloud_var</span> <span class="o">=</span>
<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">'primary_cloud'</span><span class="p">,</span><span class="n">cloud_type</span><span class="p">,</span><span class="s">'time'</span><span class="p">,</span>
<span class="o">>>></span> <span class="n">fill_value</span><span class="o">=</span><span class="n">enum_dict</span><span class="p">[</span><span class="s">'Missing'</span><span class="p">])</span>
-<span class="o">>>></span> <span class="c"># write some data to the variable.</span>
+<span class="o">>>></span> <span class="c1"># write some data to the variable.</span>
<span class="o">>>></span> <span class="n">cloud_var</span><span class="p">[:]</span> <span class="o">=</span> <span class="p">[</span><span class="n">enum_dict</span><span class="p">[</span><span class="s">'Clear'</span><span class="p">],</span><span class="n">enum_dict</span><span class="p">[</span><span class="s">'Stratus'</span><span class="p">],</span>
<span class="o">>>></span> <span class="n">enum_dict</span><span class="p">[</span><span class="s">'Cumulus'</span><span class="p">],</span><span class="n">enum_dict</span><span class="p">[</span><span class="s">'Missing'</span><span class="p">],</span>
<span class="o">>>></span> <span class="n">enum_dict</span><span class="p">[</span><span class="s">'Cumulonimbus'</span><span class="p">]]</span>
<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
-<span class="o">>>></span> <span class="c"># reopen the file, read the data.</span>
+<span class="o">>>></span> <span class="c1"># reopen the file, read the data.</span>
<span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">'clouds.nc'</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">cloud_var</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">'primary_cloud'</span><span class="p">]</span>
<span class="o">>>></span> <span class="k">print</span> <span class="n">cloud_var</span>
@@ -2813,7 +2817,7 @@ datatype.</p></div>
a scalar.</p>
<p>If <code>varname</code> is specified as a path, using forward slashes as in unix to
separate components, then intermediate groups will be created as necessary
-For example, <code>createVariable('/GroupA/GroupB/VarC'),('x','y'),float)</code> will create groups <code>GroupA</code>
+For example, <code>createVariable('/GroupA/GroupB/VarC', float, ('x','y'))</code> will create groups <code>GroupA</code>
and <code>GroupA/GroupB</code>, plus the variable <code>GroupA/GroupB/VarC</code>, if the preceding
groups don't already exist.</p>
<p>The <code>datatype</code> can be a numpy datatype object, or a string that describes
@@ -2957,9 +2961,9 @@ open/create the Dataset. Requires netcdf >= 4.1.2</p></div>
<div class="desc"><p>Returns a list of variables that match specific conditions.</p>
<p>Can pass in key=value parameters and variables are returned that
contain all of the matches. For example, </p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># Get variables with x-axis attribute.</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># Get variables with x-axis attribute.</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="s">'X'</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># Get variables with matching "standard_name" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables with matching "standard_name" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">standard_name</span><span class="o">=</span><span class="s">'northward_sea_water_velocity'</span><span class="p">)</span>
</pre></div>
@@ -2968,11 +2972,11 @@ contain all of the matches. For example, </p>
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,</p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># Get Axis variables</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># Get Axis variables</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">in</span> <span class="p">[</span><span class="s">'X'</span><span class="p">,</span> <span class="s">& [...]
-<span class="o">>>></span> <span class="c"># Get variables that don't have an "axis" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables that don't have an "axis" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># Get variables that have a "grid_mapping" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables that have a "grid_mapping" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">grid_mapping</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span><span class="p">)</span>
</pre></div></div>
<div class="source_cont">
@@ -3214,7 +3218,7 @@ with the same name as one of the reserved python attributes.</p></div>
<div class="desc"><p>set a netCDF dataset or group string attribute using name,value pair.
-Use if you need to ensure that of netCDF attribute is created with type
+Use if you need to ensure that a netCDF attribute is created with type
<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.</p></div>
<div class="source_cont">
</div>
@@ -3872,7 +3876,7 @@ datatype.</p></div>
a scalar.</p>
<p>If <code>varname</code> is specified as a path, using forward slashes as in unix to
separate components, then intermediate groups will be created as necessary
-For example, <code>createVariable('/GroupA/GroupB/VarC'),('x','y'),float)</code> will create groups <code>GroupA</code>
+For example, <code>createVariable('/GroupA/GroupB/VarC', float, ('x','y'))</code> will create groups <code>GroupA</code>
and <code>GroupA/GroupB</code>, plus the variable <code>GroupA/GroupB/VarC</code>, if the preceding
groups don't already exist.</p>
<p>The <code>datatype</code> can be a numpy datatype object, or a string that describes
@@ -4028,9 +4032,9 @@ open/create the Dataset. Requires netcdf >= 4.1.2</p></div>
<div class="desc inherited"><p>Returns a list of variables that match specific conditions.</p>
<p>Can pass in key=value parameters and variables are returned that
contain all of the matches. For example, </p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># Get variables with x-axis attribute.</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># Get variables with x-axis attribute.</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="s">'X'</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># Get variables with matching "standard_name" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables with matching "standard_name" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">standard_name</span><span class="o">=</span><span class="s">'northward_sea_water_velocity'</span><span class="p">)</span>
</pre></div>
@@ -4039,11 +4043,11 @@ contain all of the matches. For example, </p>
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,</p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># Get Axis variables</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># Get Axis variables</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">in</span> <span class="p">[</span><span class="s">'X'</span><span class="p">,</span> <span class="s">& [...]
-<span class="o">>>></span> <span class="c"># Get variables that don't have an "axis" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables that don't have an "axis" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># Get variables that have a "grid_mapping" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables that have a "grid_mapping" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">grid_mapping</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span><span class="p">)</span>
</pre></div></div>
<div class="source_cont">
@@ -4341,7 +4345,7 @@ with the same name as one of the reserved python attributes.</p></div>
<div class="desc inherited"><p>set a netCDF dataset or group string attribute using name,value pair.
-Use if you need to ensure that of netCDF attribute is created with type
+Use if you need to ensure that a netCDF attribute is created with type
<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.</p></div>
<div class="source_cont">
</div>
@@ -4403,15 +4407,15 @@ or NETCDF3_64BIT_DATA</code> format (<code>NETCDF4</code> Datasets won't work).<
<p>Adapted from <a href="http://pysclint.sourceforge.net/pycdf">pycdf</a> by Andre Gosselin.</p>
<p>Example usage (See <a href="#netCDF4.MFDataset.__init__"><code>__init__</code></a> for more details):</p>
<div class="codehilite"><pre><span class="o">>>></span> <span class="kn">import</span> <span class="nn">numpy</span>
-<span class="o">>>></span> <span class="c"># create a series of netCDF files with a variable sharing</span>
-<span class="o">>>></span> <span class="c"># the same unlimited dimension.</span>
+<span class="o">>>></span> <span class="c1"># create a series of netCDF files with a variable sharing</span>
+<span class="o">>>></span> <span class="c1"># the same unlimited dimension.</span>
<span class="o">>>></span> <span class="k">for</span> <span class="n">nf</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
<span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">"mftest</span><span class="si">%s</span><span class="s">.nc"</span> <span class="o">%</span> <span class="n">nf</span><span class="p">,</span><span class="s">"w"</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">"x"</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">x</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">"x"</span><span class="p">,</span><span class="s">"i"</span><span class="p">,(</span><span class="s">"x"</span><span class="p">,))</span>
<span class="o">>>></span> <span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">10</span><span class="p">]</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="n">nf</span><span class="o">*</span><span class="mi">10</span><span class="p">,</span><span class="mi">10</span><span class="o">*</span><span class="p">(</span>< [...]
<span class="o">>>></span> <span class="n">f</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
-<span class="o">>>></span> <span class="c"># now read all those files in at once, in one Dataset.</span>
+<span class="o">>>></span> <span class="c1"># now read all those files in at once, in one Dataset.</span>
<span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">MFDataset</span><span class="p">(</span><span class="s">"mftest*nc"</span><span class="p">)</span>
<span class="o">>>></span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">"x"</span><span class="p">][:]</span>
<span class="p">[</span> <span class="mi">0</span> <span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span> <span class="mi">7</span> <span class="mi">8</span> <span class="mi">9</span> <span class="mi">10</span> <span class="mi">11</span> <span class="mi">12</span> <span class="mi">13</span> <span class="mi">14</span> <span class="mi">15</span> <span class="mi">16</span> <span cla [...]
@@ -4778,7 +4782,7 @@ datatype.</p></div>
a scalar.</p>
<p>If <code>varname</code> is specified as a path, using forward slashes as in unix to
separate components, then intermediate groups will be created as necessary
-For example, <code>createVariable('/GroupA/GroupB/VarC'),('x','y'),float)</code> will create groups <code>GroupA</code>
+For example, <code>createVariable('/GroupA/GroupB/VarC', float, ('x','y'))</code> will create groups <code>GroupA</code>
and <code>GroupA/GroupB</code>, plus the variable <code>GroupA/GroupB/VarC</code>, if the preceding
groups don't already exist.</p>
<p>The <code>datatype</code> can be a numpy datatype object, or a string that describes
@@ -4934,9 +4938,9 @@ open/create the Dataset. Requires netcdf >= 4.1.2</p></div>
<div class="desc inherited"><p>Returns a list of variables that match specific conditions.</p>
<p>Can pass in key=value parameters and variables are returned that
contain all of the matches. For example, </p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># Get variables with x-axis attribute.</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># Get variables with x-axis attribute.</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="s">'X'</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># Get variables with matching "standard_name" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables with matching "standard_name" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">standard_name</span><span class="o">=</span><span class="s">'northward_sea_water_velocity'</span><span class="p">)</span>
</pre></div>
@@ -4945,11 +4949,11 @@ contain all of the matches. For example, </p>
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,</p>
-<div class="codehilite"><pre><span class="o">>>></span> <span class="c"># Get Axis variables</span>
+<div class="codehilite"><pre><span class="o">>>></span> <span class="c1"># Get Axis variables</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">in</span> <span class="p">[</span><span class="s">'X'</span><span class="p">,</span> <span class="s">& [...]
-<span class="o">>>></span> <span class="c"># Get variables that don't have an "axis" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables that don't have an "axis" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">)</span>
-<span class="o">>>></span> <span class="c"># Get variables that have a "grid_mapping" attribute</span>
+<span class="o">>>></span> <span class="c1"># Get variables that have a "grid_mapping" attribute</span>
<span class="o">>>></span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">grid_mapping</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span><span class="p">)</span>
</pre></div></div>
<div class="source_cont">
@@ -5228,7 +5232,7 @@ with the same name as one of the reserved python attributes.</p></div>
<div class="desc inherited"><p>set a netCDF dataset or group string attribute using name,value pair.
-Use if you need to ensure that of netCDF attribute is created with type
+Use if you need to ensure that a netCDF attribute is created with type
<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.</p></div>
<div class="source_cont">
</div>
@@ -5379,12 +5383,12 @@ time unit to all files. </p>
<span class="o">>>></span> <span class="n">t2</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">30</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">f1</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
<span class="o">>>></span> <span class="n">f2</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
-<span class="o">>>></span> <span class="c"># Read the two files in at once, in one Dataset.</span>
+<span class="o">>>></span> <span class="c1"># Read the two files in at once, in one Dataset.</span>
<span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">MFDataset</span><span class="p">(</span><span class="s">"mftest*nc"</span><span class="p">)</span>
<span class="o">>>></span> <span class="n">t</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">"time"</span><span class="p">]</span>
<span class="o">>>></span> <span class="k">print</span> <span class="n">t</span><span class="o">.</span><span class="n">units</span>
<span class="n">days</span> <span class="n">since</span> <span class="mi">2000</span><span class="o">-</span><span class="mo">01</span><span class="o">-</span><span class="mo">01</span>
-<span class="o">>>></span> <span class="k">print</span> <span class="n">t</span><span class="p">[</span><span class="mi">32</span><span class="p">]</span> <span class="c"># The value written in the file, inconsistent with the MF time units.</span>
+<span class="o">>>></span> <span class="k">print</span> <span class="n">t</span><span class="p">[</span><span class="mi">32</span><span class="p">]</span> <span class="c1"># The value written in the file, inconsistent with the MF time units.</span>
<span class="mi">1</span>
<span class="o">>>></span> <span class="n">T</span> <span class="o">=</span> <span class="n">MFTime</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="o">>>></span> <span class="k">print</span> <span class="n">T</span><span class="p">[</span><span class="mi">32</span><span class="p">]</span>
@@ -6110,7 +6114,7 @@ attributes.</p></div>
<div class="desc"><p>set a netCDF variable string attribute using name,value pair.
-Use if you need to ensure that of netCDF attribute is created with type
+Use if you need to ensure that a netCDF attribute is created with type
<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.</p></div>
<div class="source_cont">
</div>
diff --git a/netCDF4/_netCDF4.c b/netCDF4/_netCDF4.c
index 708552e..eacc27f 100644
--- a/netCDF4/_netCDF4.c
+++ b/netCDF4/_netCDF4.c
@@ -1,4 +1,4 @@
-/* Generated by Cython 0.23.4 */
+/* Generated by Cython 0.24 */
#define PY_SSIZE_T_CLEAN
#include "Python.h"
@@ -7,10 +7,10 @@
#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
#error Cython requires Python 2.6+ or Python 3.2+.
#else
-#define CYTHON_ABI "0_23_4"
+#define CYTHON_ABI "0_24"
#include <stddef.h>
#ifndef offsetof
-#define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+ #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
#ifndef __stdcall
@@ -36,17 +36,23 @@
#define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
-#define CYTHON_COMPILING_IN_PYPY 1
-#define CYTHON_COMPILING_IN_CPYTHON 0
+ #define CYTHON_COMPILING_IN_PYPY 1
+ #define CYTHON_COMPILING_IN_CPYTHON 0
#else
-#define CYTHON_COMPILING_IN_PYPY 0
-#define CYTHON_COMPILING_IN_CPYTHON 1
+ #define CYTHON_COMPILING_IN_PYPY 0
+ #define CYTHON_COMPILING_IN_CPYTHON 1
#endif
#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000
-#define CYTHON_USE_PYLONG_INTERNALS 1
+ #define CYTHON_USE_PYLONG_INTERNALS 1
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+ #include "longintrepr.h"
+ #undef SHIFT
+ #undef BASE
+ #undef MASK
#endif
#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
-#define Py_OptimizeFlag 0
+ #define Py_OptimizeFlag 0
#endif
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
@@ -82,6 +88,7 @@
#define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)
#define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)
#define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
#else
#define CYTHON_PEP393_ENABLED 0
#define __Pyx_PyUnicode_READY(op) (0)
@@ -90,6 +97,7 @@
#define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE))
#define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))
#define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))
#endif
#if CYTHON_COMPILING_IN_PYPY
#define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)
@@ -102,6 +110,14 @@
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
#define PyUnicode_Contains(u, s) PySequence_Contains(u, s)
#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
+ #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+ #define PyObject_Malloc(s) PyMem_Malloc(s)
+ #define PyObject_Free(p) PyMem_Free(p)
+ #define PyObject_Realloc(p) PyMem_Realloc(p)
+#endif
#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if PY_MAJOR_VERSION >= 3
@@ -109,6 +125,9 @@
#else
#define __Pyx_PyString_Format(a, b) PyString_Format(a, b)
#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+ #define PyObject_ASCII(o) PyObject_Repr(o)
+#endif
#if PY_MAJOR_VERSION >= 3
#define PyBaseString_Type PyUnicode_Type
#define PyStringObject PyUnicodeObject
@@ -218,6 +237,11 @@ static CYTHON_INLINE float __PYX_NAN() {
#endif
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+{ \
+ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
+}
+
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)
#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)
@@ -269,7 +293,7 @@ static CYTHON_INLINE float __PYX_NAN() {
# define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
-typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding;
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
@@ -343,7 +367,7 @@ static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
-static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
#if CYTHON_COMPILING_IN_CPYTHON
@@ -352,6 +376,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#endif
#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
static int __Pyx_sys_getdefaultencoding_not_ascii;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
@@ -442,6 +472,7 @@ static PyObject *__pyx_d;
static PyObject *__pyx_b;
static PyObject *__pyx_empty_tuple;
static PyObject *__pyx_empty_bytes;
+static PyObject *__pyx_empty_unicode;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
@@ -470,7 +501,7 @@ struct __pyx_opt_args_7netCDF4_8_netCDF4__strencode;
struct __pyx_defaults;
typedef struct __pyx_defaults __pyx_defaults;
-/* "netCDF4/_netCDF4.pyx":1198
+/* "netCDF4/_netCDF4.pyx":1211
* return 'UNDEFINED'
*
* cdef _set_att(grp, int varid, name, value,\ # <<<<<<<<<<<<<<
@@ -534,7 +565,7 @@ struct __pyx_defaults {
PyObject *__pyx_arg_exclude;
};
-/* "netCDF4/_netCDF4.pyx":1545
+/* "netCDF4/_netCDF4.pyx":1555
* __pdoc__ = {}
*
* cdef class Dataset: # <<<<<<<<<<<<<<
@@ -562,7 +593,7 @@ struct __pyx_obj_7netCDF4_8_netCDF4_Dataset {
};
-/* "netCDF4/_netCDF4.pyx":2540
+/* "netCDF4/_netCDF4.pyx":2550
*
*
* cdef class Group(Dataset): # <<<<<<<<<<<<<<
@@ -574,7 +605,7 @@ struct __pyx_obj_7netCDF4_8_netCDF4_Group {
};
-/* "netCDF4/_netCDF4.pyx":2635
+/* "netCDF4/_netCDF4.pyx":2645
*
*
* cdef class Dimension: # <<<<<<<<<<<<<<
@@ -591,7 +622,7 @@ struct __pyx_obj_7netCDF4_8_netCDF4_Dimension {
};
-/* "netCDF4/_netCDF4.pyx":2796
+/* "netCDF4/_netCDF4.pyx":2806
* return False
*
* cdef class Variable: # <<<<<<<<<<<<<<
@@ -667,7 +698,7 @@ struct __pyx_obj_7netCDF4_8_netCDF4_EnumType {
};
-/* "netCDF4/_netCDF4.pyx":1018
+/* "netCDF4/_netCDF4.pyx":1031
* _format_dict['NETCDF3_64BIT'] = NC_FORMAT_64BIT
* # invert dictionary mapping
* _reverse_format_dict = dict((v, k) for k, v in _format_dict.iteritems()) # <<<<<<<<<<<<<<
@@ -682,6 +713,7 @@ struct __pyx_obj_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr {
/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
#define CYTHON_REFNANNY 0
#endif
@@ -744,6 +776,7 @@ struct __pyx_obj_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr {
#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+/* PyObjectGetAttrStr.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
PyTypeObject* tp = Py_TYPE(obj);
@@ -759,62 +792,102 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif
+/* GetBuiltinName.proto */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+/* IterFinish.proto */
static CYTHON_INLINE int __Pyx_IterFinish(void);
+/* PyObjectCall.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif
+/* PyObjectCallMethO.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif
+/* PyObjectCallNoArg.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
#else
#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
#endif
+/* PyObjectCallOneArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+/* PyObjectCallMethod0.proto */
static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
+/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+/* UnpackItemEndCheck.proto */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
+/* RaiseNoneIterError.proto */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+/* UnpackTupleError.proto */
static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index);
+/* UnpackTuple2.proto */
static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** value1, PyObject** value2,
int is_tuple, int has_known_size, int decref_tuple);
+/* dict_iter.proto */
static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name,
Py_ssize_t* p_orig_length, int* p_is_dict);
static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);
+/* GetModuleGlobalName.proto */
static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);
+/* IncludeStringH.proto */
#include <string.h>
+/* decode_c_string.proto */
static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
const char* cstring, Py_ssize_t start, Py_ssize_t stop,
const char* encoding, const char* errors,
PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
-static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb);
-static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb);
+/* PyThreadStateGet.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET();
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)
+#endif
+/* RaiseException.proto */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+/* ListAppend.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
PyListObject* L = (PyListObject*) list;
@@ -831,18 +904,23 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
#endif
+/* ExtTypeTest.proto */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+/* BytesEquals.proto */
static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
+/* UnicodeEquals.proto */
static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
+/* StrEquals.proto */
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals
#else
#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals
#endif
+/* GetItemInt.proto */
#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
@@ -864,30 +942,58 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
int is_list, int wraparound, int boundscheck);
-static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb);
-static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb);
+/* SaveResetException.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb)
+#endif
+/* PyErrExceptionMatches.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)
+#endif
+
+/* GetException.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+/* RaiseDoubleKeywords.proto */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+/* ParseKeywords.proto */
static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
const char* function_name);
+/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+/* PySequenceContains.proto */
static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) {
int result = PySequence_Contains(seq, item);
return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
}
+/* SliceObject.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,
PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
int has_cstart, int has_cstop, int wraparound);
+/* StringJoin.proto */
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyString_Join __Pyx_PyBytes_Join
#define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v))
@@ -905,6 +1011,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values);
#endif
+/* ListCompAppend.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
PyListObject* L = (PyListObject*) list;
@@ -921,10 +1028,13 @@ static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
#endif
+/* KeywordStringCheck.proto */
static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
+/* py_dict_items.proto */
static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d);
+/* UnpackUnboundCMethod.proto */
typedef struct {
PyObject *type;
PyObject **method_name;
@@ -933,6 +1043,7 @@ typedef struct {
int flag;
} __Pyx_CachedCFunction;
+/* CallUnboundCMethod0.proto */
static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self);
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_CallUnboundCMethod0(cfunc, self)\
@@ -945,21 +1056,26 @@ static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObje
#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self)
#endif
+/* CallableCheck.proto */
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
#define __Pyx_PyCallable_Check(obj) ((obj)->ob_type->tp_call != NULL)
#else
#define __Pyx_PyCallable_Check(obj) PyCallable_Check(obj)
#endif
+/* GetAttr.proto */
static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
+/* GetAttr3.proto */
static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
+/* PyDictContains.proto */
static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) {
int result = PyDict_Contains(dict, item);
return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
}
+/* DictGetItem.proto */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
PyObject *value;
@@ -980,8 +1096,10 @@ static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#endif
+/* None.proto */
static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
+/* PyObjectSetAttrStr.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL)
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
@@ -999,6 +1117,7 @@ static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr
#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
#endif
+/* PyIntBinop.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
#else
@@ -1006,6 +1125,7 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval,
(inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
#endif
+/* PyIntBinop.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
#else
@@ -1013,6 +1133,7 @@ static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, i
PyObject_RichCompare(op1, op2, Py_EQ)
#endif
+/* SetItemInt.proto */
#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
@@ -1022,6 +1143,7 @@ static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyOb
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
int is_list, int wraparound, int boundscheck);
+/* pyobject_as_double.proto */
static double __Pyx__PyObject_AsDouble(PyObject* obj);
#if CYTHON_COMPILING_IN_PYPY
#define __Pyx_PyObject_AsDouble(obj)\
@@ -1034,6 +1156,7 @@ static double __Pyx__PyObject_AsDouble(PyObject* obj);
PyFloat_AS_DOUBLE(obj) : __Pyx__PyObject_AsDouble(obj))
#endif
+/* SliceObject.proto */
#define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)\
__Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)
static CYTHON_INLINE int __Pyx_PyObject_SetSlice(
@@ -1041,9 +1164,11 @@ static CYTHON_INLINE int __Pyx_PyObject_SetSlice(
PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
int has_cstart, int has_cstop, int wraparound);
+/* ArgTypeTest.proto */
static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
const char *name, int exact);
+/* PyIntBinop.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
#else
@@ -1051,10 +1176,13 @@ static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long int
(inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2))
#endif
+/* PyObjectCallMethod1.proto */
static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg);
+/* append.proto */
static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x);
+/* PyFloatBinop.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double floatval, int inplace);
#else
@@ -1062,8 +1190,10 @@ static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double f
((inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2)))
#endif
+/* py_dict_keys.proto */
static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d);
+/* ListExtend.proto */
static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) {
#if CYTHON_COMPILING_IN_CPYTHON
PyObject* none = _PyList_Extend((PyListObject*)L, v);
@@ -1076,14 +1206,19 @@ static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) {
#endif
}
+/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+/* ImportFrom.proto */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
+/* CalculateMetaclass.proto */
static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
+/* FetchCommonType.proto */
static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
+/* CythonFunction.proto */
#define __Pyx_CyFunction_USED 1
#include <structmember.h>
#define __Pyx_CYFUNCTION_STATICMETHOD 0x01
@@ -1137,14 +1272,16 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
PyObject *dict);
static int __pyx_CyFunction_init(void);
+/* Py3ClassCreate.proto */
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname,
PyObject *mkw, PyObject *modname, PyObject *doc);
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict,
PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass);
+/* CodeObjectCache.proto */
typedef struct {
- int code_line;
PyCodeObject* code_object;
+ int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
int count;
@@ -1156,41 +1293,63 @@ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int co
static PyCodeObject *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
int py_line, const char *filename);
+/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value);
+/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PY_LONG_LONG(PY_LONG_LONG value);
+/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value);
+/* ForceInitThreads.proto */
#ifndef __PYX_FORCE_INIT_THREADS
#define __PYX_FORCE_INIT_THREADS 0
#endif
-static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
-
+/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_nc_type(nc_type value);
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_intp(npy_intp value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntFromPy.proto */
static CYTHON_INLINE nc_type __Pyx_PyInt_As_nc_type(PyObject *);
+/* CIntFromPy.proto */
static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
+/* CIntFromPy.proto */
static CYTHON_INLINE ptrdiff_t __Pyx_PyInt_As_ptrdiff_t(PyObject *);
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_intp(npy_intp value);
-
+/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value);
-
+/* SwapException.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+/* CoroutineBase.proto */
typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyObject *);
typedef struct {
PyObject_HEAD
@@ -1216,10 +1375,13 @@ static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue);
#define __Pyx_PyGen_FetchStopIterationValue(pvalue) PyGen_FetchStopIterationValue(pvalue)
#endif
+/* PatchModuleWithCoroutine.proto */
static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code);
+/* PatchGeneratorABC.proto */
static int __Pyx_patch_abc(void);
+/* Generator.proto */
#define __Pyx_Generator_USED
static PyTypeObject *__pyx_GeneratorType = 0;
#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType)
@@ -1228,8 +1390,10 @@ static PyTypeObject *__pyx_GeneratorType = 0;
static PyObject *__Pyx_Generator_Next(PyObject *self);
static int __pyx_Generator_init(void);
+/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(void);
+/* PyIdentifierFromString.proto */
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
@@ -1238,10 +1402,13 @@ static int __Pyx_check_binary_version(void);
#endif
#endif
+/* ModuleImport.proto */
static PyObject *__Pyx_ImportModule(const char *name);
+/* TypeImport.proto */
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);
+/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
@@ -1284,712 +1451,708 @@ int __pyx_module_is_main_netCDF4___netCDF4 = 0;
/* Implementation of 'netCDF4._netCDF4' */
static PyObject *__pyx_builtin_ImportError;
static PyObject *__pyx_builtin_object;
-static PyObject *__pyx_builtin_RuntimeError;
static PyObject *__pyx_builtin_AttributeError;
static PyObject *__pyx_builtin_KeyError;
static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_RuntimeError;
static PyObject *__pyx_builtin_UnicodeError;
static PyObject *__pyx_builtin_TypeError;
-static PyObject *__pyx_builtin_IndexError;
static PyObject *__pyx_builtin_IOError;
+static PyObject *__pyx_builtin_IndexError;
static PyObject *__pyx_builtin_enumerate;
static PyObject *__pyx_builtin_Ellipsis;
static PyObject *__pyx_builtin_sum;
static PyObject *__pyx_builtin_range;
static PyObject *__pyx_builtin_UnicodeDecodeError;
-static char __pyx_k_[] = "\000";
-static char __pyx_k_1[] = "1";
-static char __pyx_k_O[] = "O";
-static char __pyx_k_S[] = "S";
-static char __pyx_k_U[] = "U";
-static char __pyx_k_V[] = "V";
-static char __pyx_k_a[] = "a";
-static char __pyx_k_b[] = "b";
-static char __pyx_k_d[] = "d";
-static char __pyx_k_f[] = "f";
-static char __pyx_k_i[] = "i";
-static char __pyx_k_k[] = "k";
-static char __pyx_k_n[] = "n";
-static char __pyx_k_r[] = "r";
-static char __pyx_k_s[] = "(%s)";
-static char __pyx_k_t[] = "t";
-static char __pyx_k_u[] = "u'";
-static char __pyx_k_v[] = "v";
-static char __pyx_k_w[] = "w";
-static char __pyx_k_0m[] = "\033[0m";
-static char __pyx_k_4m[] = " \033[4m";
-static char __pyx_k_S1[] = "S1";
-static char __pyx_k__2[] = "";
-static char __pyx_k_as[] = "as";
-static char __pyx_k_bs[] = "bs";
-static char __pyx_k_dt[] = "dt";
-static char __pyx_k_f4[] = "f4";
-static char __pyx_k_f8[] = "f8";
-static char __pyx_k_i0[] = "i0";
-static char __pyx_k_i1[] = "i1";
-static char __pyx_k_i2[] = "i2";
-static char __pyx_k_i4[] = "i4";
-static char __pyx_k_i8[] = "i8";
-static char __pyx_k_id[] = "id";
-static char __pyx_k_iu[] = "iu";
-static char __pyx_k_ma[] = "ma";
-static char __pyx_k_n1[] = "n1";
-static char __pyx_k_nv[] = "nv";
-static char __pyx_k_td[] = "td";
-static char __pyx_k_u1[] = "u1";
-static char __pyx_k_u2[] = "u2";
-static char __pyx_k_u4[] = "u4";
-static char __pyx_k_u8[] = "u8";
-static char __pyx_k_ws[] = "ws";
-static char __pyx_k__14[] = "<";
-static char __pyx_k__15[] = ">";
-static char __pyx_k__16[] = "/";
-static char __pyx_k__19[] = "'";
-static char __pyx_k__21[] = ", ";
-static char __pyx_k__22[] = ",";
-static char __pyx_k__24[] = ",)";
-static char __pyx_k__25[] = ")";
-static char __pyx_k__28[] = "__";
-static char __pyx_k__36[] = "=";
-static char __pyx_k__37[] = "|";
-static char __pyx_k_all[] = "all";
-static char __pyx_k_any[] = "any";
-static char __pyx_k_arr[] = "arr";
-static char __pyx_k_big[] = "big";
-static char __pyx_k_cdf[] = "_cdf";
-static char __pyx_k_cnt[] = "cnt";
-static char __pyx_k_dat[] = "dat";
-static char __pyx_k_day[] = "day";
-static char __pyx_k_dim[] = "dim";
-static char __pyx_k_doc[] = "__doc__";
-static char __pyx_k_get[] = "_get";
-static char __pyx_k_grp[] = "grp";
-static char __pyx_k_idx[] = "idx";
-static char __pyx_k_ind[] = "ind";
-static char __pyx_k_key[] = "_key";
-static char __pyx_k_len[] = "__len__";
-static char __pyx_k_lst[] = "lst";
-static char __pyx_k_msg[] = "msg";
-static char __pyx_k_num[] = "num";
-static char __pyx_k_pop[] = "pop";
-static char __pyx_k_put[] = "put";
-static char __pyx_k_r_2[] = "r+";
-static char __pyx_k_r_3[] = "%r\n";
-static char __pyx_k_r_s[] = "r+s";
-static char __pyx_k_s_2[] = "s";
-static char __pyx_k_s_s[] = " %s: %s\n";
-static char __pyx_k_sta[] = "sta";
-static char __pyx_k_str[] = "str";
-static char __pyx_k_sum[] = "sum";
-static char __pyx_k_sys[] = "sys";
-static char __pyx_k_val[] = "val";
-static char __pyx_k_var[] = "var";
-static char __pyx_k_vid[] = "vid";
-static char __pyx_k_zip[] = "zip";
-static char __pyx_k_HDF4[] = "HDF4";
-static char __pyx_k_args[] = "args";
-static char __pyx_k_bool[] = "bool";
-static char __pyx_k_cdfm[] = "cdfm";
-static char __pyx_k_char[] = "char";
-static char __pyx_k_copy[] = "copy";
-static char __pyx_k_data[] = "data";
-static char __pyx_k_date[] = "date";
-static char __pyx_k_days[] = "days";
-static char __pyx_k_dict[] = "__dict__";
-static char __pyx_k_dims[] = "_dims";
-static char __pyx_k_dset[] = "dset";
-static char __pyx_k_elem[] = "elem";
-static char __pyx_k_enum[] = "enum";
-static char __pyx_k_f4_2[] = "<f4";
-static char __pyx_k_f4_3[] = ">f4";
-static char __pyx_k_find[] = "find";
-static char __pyx_k_flat[] = "flat";
-static char __pyx_k_glob[] = "glob";
-static char __pyx_k_grps[] = "_grps";
-static char __pyx_k_hour[] = "hour";
-static char __pyx_k_http[] = "http";
-static char __pyx_k_in1d[] = "in1d";
-static char __pyx_k_init[] = "__init__";
-static char __pyx_k_isMA[] = "isMA";
-static char __pyx_k_item[] = "item";
-static char __pyx_k_izip[] = "izip";
-static char __pyx_k_join[] = "join";
-static char __pyx_k_keys[] = "keys";
-static char __pyx_k_kind[] = "kind";
-static char __pyx_k_main[] = "__main__";
-static char __pyx_k_mask[] = "mask";
-static char __pyx_k_mode[] = "mode";
-static char __pyx_k_name[] = "name";
-static char __pyx_k_ndim[] = "ndim";
-static char __pyx_k_numv[] = "numv";
-static char __pyx_k_part[] = "part";
-static char __pyx_k_path[] = "path";
-static char __pyx_k_pdoc[] = "__pdoc__";
-static char __pyx_k_prod[] = "prod";
-static char __pyx_k_repr[] = "__repr__";
-static char __pyx_k_secs[] = "secs";
-static char __pyx_k_self[] = "self";
-static char __pyx_k_send[] = "send";
-static char __pyx_k_size[] = "size";
-static char __pyx_k_slen[] = "slen";
-static char __pyx_k_step[] = "step";
-static char __pyx_k_stop[] = "stop";
-static char __pyx_k_strd[] = "strd";
-static char __pyx_k_strt[] = "strt";
-static char __pyx_k_test[] = "__test__";
-static char __pyx_k_tile[] = "tile";
-static char __pyx_k_time[] = "time";
-static char __pyx_k_toma[] = "_toma";
-static char __pyx_k_unit[] = "unit";
-static char __pyx_k_vars[] = "_vars";
-static char __pyx_k_view[] = "view";
-static char __pyx_k_vlen[] = "vlen";
-static char __pyx_k_warn[] = "warn";
-static char __pyx_k_year[] = "year";
-static char __pyx_k_zlib[] = "zlib";
-static char __pyx_k_1_2_3[] = "1.2.3";
-static char __pyx_k_4_2_1[] = "4.2.1";
-static char __pyx_k_4_4_0[] = "4.4.0";
-static char __pyx_k_align[] = "align";
-static char __pyx_k_array[] = "array";
-static char __pyx_k_ascii[] = "ascii";
-static char __pyx_k_attrs[] = "attrs";
-static char __pyx_k_atype[] = "atype";
-static char __pyx_k_cdf_2[] = "cdf";
-static char __pyx_k_check[] = "check";
-static char __pyx_k_close[] = "close";
-static char __pyx_k_count[] = "count";
-static char __pyx_k_d_d_d[] = "%d.%d.%d";
-static char __pyx_k_dates[] = "dates";
-static char __pyx_k_dimid[] = "_dimid";
-static char __pyx_k_dtype[] = "dtype";
-static char __pyx_k_empty[] = "empty";
-static char __pyx_k_exact[] = "exact";
-static char __pyx_k_files[] = "files";
-static char __pyx_k_float[] = "float";
-static char __pyx_k_grp_2[] = "_grp";
-static char __pyx_k_grpid[] = "_grpid";
-static char __pyx_k_isnan[] = "isnan";
-static char __pyx_k_items[] = "items";
-static char __pyx_k_lower[] = "lower";
-static char __pyx_k_month[] = "month";
-static char __pyx_k_msecs[] = "msecs";
-static char __pyx_k_names[] = "names";
-static char __pyx_k_numpy[] = "numpy";
-static char __pyx_k_proxy[] = "proxy";
-static char __pyx_k_put_2[] = "_put";
-static char __pyx_k_range[] = "range";
-static char __pyx_k_ravel[] = "ravel";
-static char __pyx_k_redef[] = "_redef";
-static char __pyx_k_round[] = "round";
-static char __pyx_k_s_s_s[] = "%s %s(%s)\n";
-static char __pyx_k_scale[] = "scale";
-static char __pyx_k_shape[] = "shape";
-static char __pyx_k_since[] = "since";
-static char __pyx_k_split[] = "split";
-static char __pyx_k_start[] = "start";
-static char __pyx_k_strip[] = "strip";
-static char __pyx_k_throw[] = "throw";
-static char __pyx_k_times[] = "times";
-static char __pyx_k_tostr[] = "_tostr";
-static char __pyx_k_tsecs[] = "tsecs";
-static char __pyx_k_units[] = "units";
-static char __pyx_k_utf_8[] = "utf-8";
-static char __pyx_k_utils[] = "utils";
-static char __pyx_k_utime[] = "utime";
-static char __pyx_k_vInst[] = "vInst";
-static char __pyx_k_vName[] = "vName";
-static char __pyx_k_value[] = "value";
-static char __pyx_k_varid[] = "_varid";
-static char __pyx_k_zeros[] = "zeros";
-static char __pyx_k_MFTime[] = "MFTime";
-static char __pyx_k_aggdim[] = "aggdim";
-static char __pyx_k_append[] = "append";
-static char __pyx_k_around[] = "around";
-static char __pyx_k_astype[] = "astype";
-static char __pyx_k_decode[] = "decode";
-static char __pyx_k_dims_2[] = "dims";
-static char __pyx_k_dset_2[] = "_dset";
-static char __pyx_k_encode[] = "encode";
-static char __pyx_k_enddef[] = "_enddef";
-static char __pyx_k_endian[] = "endian";
-static char __pyx_k_fields[] = "fields";
-static char __pyx_k_filled[] = "filled";
-static char __pyx_k_format[] = "format";
-static char __pyx_k_groups[] = "groups";
-static char __pyx_k_import[] = "__import__";
-static char __pyx_k_isenum[] = "_isenum";
-static char __pyx_k_isvlen[] = "_isvlen";
-static char __pyx_k_julian[] = "julian";
-static char __pyx_k_little[] = "little";
-static char __pyx_k_lstArr[] = "lstArr";
-static char __pyx_k_master[] = "master";
-static char __pyx_k_minute[] = "minute";
-static char __pyx_k_module[] = "__module__";
-static char __pyx_k_msecsd[] = "msecsd";
-static char __pyx_k_name_2[] = "_name";
-static char __pyx_k_native[] = "native";
-static char __pyx_k_nbytes[] = "nbytes";
-static char __pyx_k_ncdump[] = "ncdump";
-static char __pyx_k_nctime[] = "nctime";
-static char __pyx_k_nelems[] = "nelems";
-static char __pyx_k_object[] = "object";
-static char __pyx_k_parent[] = "parent";
-static char __pyx_k_path_2[] = "_path";
-static char __pyx_k_path_s[] = "path = %s\n";
-static char __pyx_k_recLen[] = "_recLen";
-static char __pyx_k_recVar[] = "_recVar";
-static char __pyx_k_second[] = "second";
-static char __pyx_k_select[] = "select";
-static char __pyx_k_stride[] = "stride";
-static char __pyx_k_string[] = "string";
-static char __pyx_k_tolist[] = "tolist";
-static char __pyx_k_typeid[] = "typeid";
-static char __pyx_k_values[] = "values";
-static char __pyx_k_vltype[] = "_vltype";
-static char __pyx_k_IOError[] = "IOError";
-static char __pyx_k_MINYEAR[] = "MINYEAR";
-static char __pyx_k_NETCDF3[] = "NETCDF3";
-static char __pyx_k_NETCDF4[] = "NETCDF4";
-static char __pyx_k_asarray[] = "asarray";
-static char __pyx_k_bytestr[] = "bytestr";
-static char __pyx_k_cdfTLen[] = "_cdfTLen";
-static char __pyx_k_cdfVLen[] = "_cdfVLen";
-static char __pyx_k_cdftime[] = "cdftime";
-static char __pyx_k_clobber[] = "clobber";
-static char __pyx_k_cmptype[] = "_cmptype";
-static char __pyx_k_d_d_d_s[] = "%d.%d.%d-%s";
-static char __pyx_k_dimlens[] = "dimlens";
-static char __pyx_k_dimname[] = "dimname";
-static char __pyx_k_exclude[] = "exclude";
-static char __pyx_k_extDims[] = "extDims";
-static char __pyx_k_extType[] = "extType";
-static char __pyx_k_files_2[] = "_files";
-static char __pyx_k_flatten[] = "flatten";
-static char __pyx_k_formats[] = "formats";
-static char __pyx_k_genexpr[] = "genexpr";
-static char __pyx_k_getattr[] = "__getattr__";
-static char __pyx_k_getdims[] = "_getdims";
-static char __pyx_k_getitem[] = "__getitem__";
-static char __pyx_k_getname[] = "_getname";
-static char __pyx_k_group_s[] = "group %s:\n";
-static char __pyx_k_has_lsd[] = "_has_lsd";
-static char __pyx_k_nc_type[] = "_nc_type";
-static char __pyx_k_ncattrs[] = "ncattrs";
-static char __pyx_k_newname[] = "newname";
-static char __pyx_k_offsets[] = "offsets";
-static char __pyx_k_oldname[] = "oldname";
-static char __pyx_k_persist[] = "persist";
-static char __pyx_k_prepare[] = "__prepare__";
-static char __pyx_k_put_ind[] = "put_ind";
-static char __pyx_k_python3[] = "python3";
-static char __pyx_k_ref_num[] = "ref_num";
-static char __pyx_k_replace[] = "replace";
-static char __pyx_k_reshape[] = "reshape";
-static char __pyx_k_s_s_s_2[] = "%s %s%s\n";
-static char __pyx_k_seconds[] = "seconds";
-static char __pyx_k_setattr[] = "__setattr__";
-static char __pyx_k_shape_2[] = "_shape";
-static char __pyx_k_shuffle[] = "shuffle";
-static char __pyx_k_squeeze[] = "squeeze";
-static char __pyx_k_timestr[] = "timestr";
-static char __pyx_k_unicode[] = "__unicode__";
-static char __pyx_k_value_2[] = "_value";
-static char __pyx_k_varInfo[] = "varInfo";
-static char __pyx_k_varname[] = "varname";
-static char __pyx_k_version[] = "__version__";
-static char __pyx_k_vltypes[] = "vltypes";
-static char __pyx_k_weakref[] = "weakref";
-static char __pyx_k_Ellipsis[] = "Ellipsis";
-static char __pyx_k_KeyError[] = "KeyError";
-static char __pyx_k_NUMCHARS[] = "NUMCHARS";
-static char __pyx_k_Variable[] = "_Variable";
-static char __pyx_k_aggDimId[] = "aggDimId";
-static char __pyx_k_basedate[] = "basedate";
-static char __pyx_k_byteswap[] = "byteswap";
-static char __pyx_k_calendar[] = "calendar";
-static char __pyx_k_cmptypes[] = "cmptypes";
-static char __pyx_k_compound[] = "compound";
-static char __pyx_k_datatype[] = "datatype";
-static char __pyx_k_date2num[] = "date2num";
-static char __pyx_k_datetime[] = "datetime";
-static char __pyx_k_dimnames[] = "dimnames";
-static char __pyx_k_diskless[] = "diskless";
-static char __pyx_k_encoding[] = "encoding";
-static char __pyx_k_endswith[] = "endswith";
-static char __pyx_k_enumtype[] = "_enumtype";
-static char __pyx_k_extShape[] = "extShape";
-static char __pyx_k_filename[] = "filename";
-static char __pyx_k_find_dim[] = "_find_dim";
-static char __pyx_k_groups_s[] = " groups: %s\n";
-static char __pyx_k_grpnames[] = "grpnames";
-static char __pyx_k_has_cdf5[] = "__has_cdf5__";
-static char __pyx_k_hr_units[] = "hr_units";
-static char __pyx_k_ismasked[] = "ismasked";
-static char __pyx_k_isscalar[] = "isscalar";
-static char __pyx_k_itemsize[] = "itemsize";
-static char __pyx_k_newSlice[] = "newSlice";
-static char __pyx_k_normpath[] = "normpath";
-static char __pyx_k_num2date[] = "num2date";
-static char __pyx_k_qualname[] = "__qualname__";
-static char __pyx_k_quantize[] = "_quantize";
-static char __pyx_k_ref_date[] = "ref_date";
-static char __pyx_k_standard[] = "standard";
-static char __pyx_k_subdtype[] = "subdtype";
-static char __pyx_k_to_ascii[] = "_to_ascii";
-static char __pyx_k_tostring[] = "tostring";
-static char __pyx_k_typecode[] = "typecode";
-static char __pyx_k_varnames[] = "varnames";
-static char __pyx_k_warnings[] = "warnings";
-static char __pyx_k_Dimension[] = "_Dimension";
-static char __pyx_k_FillValue[] = "_FillValue";
-static char __pyx_k_MFDataset[] = "MFDataset";
-static char __pyx_k_TypeError[] = "TypeError";
-static char __pyx_k_UNDEFINED[] = "UNDEFINED";
-static char __pyx_k_byteorder[] = "byteorder";
-static char __pyx_k_cdfRecVar[] = "_cdfRecVar";
-static char __pyx_k_cdfVLen_2[] = "cdfVLen";
-static char __pyx_k_complevel[] = "complevel";
-static char __pyx_k_datashape[] = "datashape";
-static char __pyx_k_dateparse[] = "_dateparse";
-static char __pyx_k_day_units[] = "day_units";
-static char __pyx_k_delncattr[] = "delncattr";
-static char __pyx_k_dimtotlen[] = "dimtotlen";
-static char __pyx_k_enum_dict[] = "enum_dict";
-static char __pyx_k_enumerate[] = "enumerate";
-static char __pyx_k_enumtypes[] = "enumtypes";
-static char __pyx_k_getncattr[] = "getncattr";
-static char __pyx_k_gregorian[] = "gregorian";
-static char __pyx_k_isostring[] = "isostring";
-static char __pyx_k_iteritems[] = "iteritems";
-static char __pyx_k_itertools[] = "itertools";
-static char __pyx_k_majorvers[] = "majorvers";
-static char __pyx_k_mastervar[] = "_mastervar";
-static char __pyx_k_metaclass[] = "__metaclass__";
-static char __pyx_k_min_units[] = "min_units";
-static char __pyx_k_minorvers[] = "minorvers";
-static char __pyx_k_nunlimdim[] = "_nunlimdim";
-static char __pyx_k_posixpath[] = "posixpath";
-static char __pyx_k_recdimlen[] = "recdimlen";
-static char __pyx_k_sec_units[] = "sec_units";
-static char __pyx_k_setncattr[] = "setncattr";
-static char __pyx_k_timedelta[] = "timedelta";
-static char __pyx_k_totaltime[] = "totaltime";
-static char __pyx_k_traceback[] = "traceback";
-static char __pyx_k_unlimdims[] = "unlimdims";
-static char __pyx_k_variables[] = "variables";
-static char __pyx_k_walk_grps[] = "_walk_grps";
-static char __pyx_k_Group_name[] = "Group.name";
-static char __pyx_k_IndexError[] = "IndexError";
-static char __pyx_k_ValueError[] = "ValueError";
-static char __pyx_k_add_offset[] = "add_offset";
-static char __pyx_k_aggDimName[] = "aggDimName";
-static char __pyx_k_chunksizes[] = "chunksizes";
-static char __pyx_k_contiguous[] = "contiguous";
-static char __pyx_k_data_model[] = "data_model";
-static char __pyx_k_date2index[] = "date2index";
-static char __pyx_k_dimensions[] = "dimensions";
-static char __pyx_k_dtype_name[] = "dtype_name";
-static char __pyx_k_fill_value[] = "fill_value";
-static char __pyx_k_filling_on[] = "filling on";
-static char __pyx_k_fletcher32[] = "fletcher32";
-static char __pyx_k_groups_s_2[] = " groups = %s\n";
-static char __pyx_k_iscompound[] = "_iscompound";
-static char __pyx_k_masterDims[] = "masterDims";
-static char __pyx_k_masterType[] = "masterType";
-static char __pyx_k_ncdump_var[] = "ncdump_var";
-static char __pyx_k_nctonptype[] = "_nctonptype";
-static char __pyx_k_netcdftime[] = "netcdftime";
-static char __pyx_k_nptonctype[] = "_nptonctype";
-static char __pyx_k_parse_date[] = "_parse_date";
-static char __pyx_k_preemption[] = "preemption";
-static char __pyx_k_recdimname[] = "recdimname";
-static char __pyx_k_sortbylist[] = "_sortbylist";
-static char __pyx_k_startswith[] = "startswith";
-static char __pyx_k_time2index[] = "time2index";
-static char __pyx_k_utc_offset[] = "utc_offset";
-static char __pyx_k_ImportError[] = "ImportError";
-static char __pyx_k_NC_DISKLESS[] = "NC_DISKLESS";
-static char __pyx_k_OrderedDict[] = "OrderedDict";
-static char __pyx_k_String_name[] = "String name.";
-static char __pyx_k_VLType_name[] = "VLType.name";
-static char __pyx_k_assign_vlen[] = "_assign_vlen";
-static char __pyx_k_cdfRecVar_2[] = "cdfRecVar";
-static char __pyx_k_chunk_cache[] = "chunk_cache";
-static char __pyx_k_collections[] = "collections";
-static char __pyx_k_concatenate[] = "concatenate";
-static char __pyx_k_createGroup[] = "createGroup";
-static char __pyx_k_development[] = "-development";
-static char __pyx_k_disk_format[] = "disk_format";
-static char __pyx_k_file_format[] = "file_format";
-static char __pyx_k_filling_off[] = "filling off\n";
-static char __pyx_k_format_dict[] = "_format_dict";
-static char __pyx_k_isprimitive[] = "_isprimitive";
-static char __pyx_k_isunlimited[] = "isunlimited";
-static char __pyx_k_keepweakref[] = "keepweakref";
-static char __pyx_k_masterShape[] = "masterShape";
-static char __pyx_k_ordereddict[] = "ordereddict";
-static char __pyx_k_patchstring[] = "patchstring";
-static char __pyx_k_releasevers[] = "releasevers";
-static char __pyx_k_string_type[] = ": string type";
-static char __pyx_k_stringtoarr[] = "stringtoarr";
-static char __pyx_k_variables_s[] = " variables = %s\n";
-static char __pyx_k_Dataset_path[] = "Dataset.path";
-static char __pyx_k_MFTime__time[] = "_MFTime__time";
-static char __pyx_k_RuntimeError[] = "RuntimeError";
-static char __pyx_k_UnicodeError[] = "UnicodeError";
-static char __pyx_k_VLType_dtype[] = "VLType.dtype";
-static char __pyx_k_chartostring[] = "chartostring";
-static char __pyx_k_data_model_2[] = "_data_model";
-static char __pyx_k_dimensions_s[] = " dimensions = %s\n";
-static char __pyx_k_getattribute[] = "__getattribute__";
-static char __pyx_k_masked_array[] = "masked_array";
-static char __pyx_k_masterRecVar[] = "masterRecVar";
-static char __pyx_k_microseconds[] = "microseconds";
-static char __pyx_k_private_atts[] = "_private_atts";
-static char __pyx_k_recdimname_2[] = "_recdimname";
-static char __pyx_k_scale_factor[] = "scale_factor";
-static char __pyx_k_stringtochar[] = "stringtochar";
-static char __pyx_k_version_info[] = "version_info";
-static char __pyx_k_EnumType_name[] = "EnumType.name";
-static char __pyx_k_Illegal_index[] = "Illegal index";
-static char __pyx_k_MFTime___init[] = "MFTime.__init__";
-static char __pyx_k_MFTime__delta[] = "_MFTime__delta";
-static char __pyx_k_NETCDF3_64BIT[] = "NETCDF3_64BIT";
-static char __pyx_k_Variable_mask[] = "Variable.mask";
-static char __pyx_k_Variable_name[] = "Variable.name";
-static char __pyx_k_Variable_ndim[] = "Variable.ndim";
-static char __pyx_k_Variable_size[] = "Variable.size";
-static char __pyx_k_datatype_name[] = "datatype_name";
-static char __pyx_k_disk_format_2[] = "_disk_format";
-static char __pyx_k_file_format_2[] = "_file_format";
-static char __pyx_k_getlibversion[] = "getlibversion";
-static char __pyx_k_intnptonctype[] = "_intnptonctype";
-static char __pyx_k_is_native_big[] = "is_native_big";
-static char __pyx_k_missing_value[] = "missing_value";
-static char __pyx_k_name_s_size_s[] = ": name = '%s', size = %s\n";
-static char __pyx_k_set_auto_mask[] = "set_auto_mask";
-static char __pyx_k_timestr_split[] = "timestr_split";
-static char __pyx_k_unicode_error[] = "unicode_error";
-static char __pyx_k_AttributeError[] = "AttributeError";
-static char __pyx_k_Dataset_groups[] = "Dataset.groups";
-static char __pyx_k_Dataset_parent[] = "Dataset.parent";
-static char __pyx_k_Dimension_name[] = "Dimension.name";
-static char __pyx_k_EnumType_dtype[] = "EnumType.dtype";
-static char __pyx_k_Variable___len[] = "_Variable.__len__";
-static char __pyx_k_Variable_dtype[] = "Variable.dtype";
-static char __pyx_k_Variable_scale[] = "Variable.scale";
-static char __pyx_k_Variable_shape[] = "Variable.shape";
-static char __pyx_k_current_size_s[] = "current size = %s\n";
-static char __pyx_k_has_rename_grp[] = "__has_rename_grp__";
-static char __pyx_k_hdf5libversion[] = "__hdf5libversion__";
-static char __pyx_k_microsec_units[] = "microsec_units";
-static char __pyx_k_millisec_units[] = "millisec_units";
-static char __pyx_k_set_auto_scale[] = "set_auto_scale";
-static char __pyx_k_supportedtypes[] = "_supportedtypes";
-static char __pyx_k_Dataset_vltypes[] = "Dataset.vltypes";
-static char __pyx_k_Dimension___len[] = "_Dimension.__len__";
-static char __pyx_k_MFDataset_close[] = "MFDataset.close";
-static char __pyx_k_NETCDF3_CLASSIC[] = "NETCDF3_CLASSIC";
-static char __pyx_k_NETCDF4_CLASSIC[] = "NETCDF4_CLASSIC";
-static char __pyx_k_Variable___init[] = "_Variable.__init__";
-static char __pyx_k_Variable___repr[] = "_Variable.__repr__";
-static char __pyx_k_Variable__shape[] = "_Variable._shape";
-static char __pyx_k_current_shape_s[] = "current shape = %s\n";
-static char __pyx_k_has_nc_inq_path[] = "__has_nc_inq_path__";
-static char __pyx_k_out_array_shape[] = "_out_array_shape";
-static char __pyx_k_Dataset_cmptypes[] = "Dataset.cmptypes";
-static char __pyx_k_Dimension___init[] = "_Dimension.__init__";
-static char __pyx_k_Dimension___repr[] = "_Dimension.__repr__";
-static char __pyx_k_MFDataset___init[] = "MFDataset.__init__";
-static char __pyx_k_MFDataset___repr[] = "MFDataset.__repr__";
-static char __pyx_k_MFTime___getitem[] = "MFTime.__getitem__";
-static char __pyx_k_StartCountStride[] = "_StartCountStride";
-static char __pyx_k_Variable_ncattrs[] = "_Variable.ncattrs";
-static char __pyx_k_default_encoding[] = "default_encoding";
-static char __pyx_k_default_fillvals[] = "default_fillvals";
-static char __pyx_k_enum_data_type_s[] = "enum data type: %s\n";
-static char __pyx_k_is_native_little[] = "is_native_little";
-static char __pyx_k_netCDF4__netCDF4[] = "netCDF4._netCDF4";
-static char __pyx_k_s_not_found_in_s[] = "%s not found in %s";
-static char __pyx_k_vlen_data_type_s[] = "vlen data type: %s\n";
-static char __pyx_k_CompoundType_name[] = "CompoundType.name";
-static char __pyx_k_Dataset_enumtypes[] = "Dataset.enumtypes";
-static char __pyx_k_Dataset_variables[] = "Dataset.variables";
-static char __pyx_k_MFDataset_ncattrs[] = "MFDataset.ncattrs";
-static char __pyx_k_Variable_datatype[] = "Variable.datatype";
-static char __pyx_k_Variable_typecode[] = "_Variable.typecode";
-static char __pyx_k_gethdf5libversion[] = "_gethdf5libversion";
-static char __pyx_k_netcdf4libversion[] = "__netcdf4libversion__";
-static char __pyx_k_CompoundType_dtype[] = "CompoundType.dtype";
-static char __pyx_k_Dataset_data_model[] = "Dataset.data_model";
-static char __pyx_k_Dataset_dimensions[] = "Dataset.dimensions";
-static char __pyx_k_EnumType_enum_dict[] = "EnumType.enum_dict";
-static char __pyx_k_UnicodeDecodeError[] = "UnicodeDecodeError";
-static char __pyx_k_Variable___getattr[] = "_Variable.__getattr__";
-static char __pyx_k_Variable___getitem[] = "_Variable.__getitem__";
-static char __pyx_k_dimensions_sizes_s[] = " dimensions(sizes): %s\n";
-static char __pyx_k_set_default_format[] = "_set_default_format";
-static char __pyx_k_Dataset_disk_format[] = "Dataset.disk_format";
-static char __pyx_k_Dataset_file_format[] = "Dataset.file_format";
-static char __pyx_k_Dataset_keepweakref[] = "Dataset.keepweakref";
-static char __pyx_k_MFDataset___setattr[] = "MFDataset.__setattr__";
-static char __pyx_k_Variable_dimensions[] = "Variable.dimensions";
-static char __pyx_k_get_var_chunk_cache[] = "get_var_chunk_cache";
-static char __pyx_k_orthogoral_indexing[] = "__orthogoral_indexing__";
-static char __pyx_k_proleptic_gregorian[] = "proleptic_gregorian";
-static char __pyx_k_reverse_format_dict[] = "_reverse_format_dict";
-static char __pyx_k_NETCDF3_64BIT_OFFSET[] = "NETCDF3_64BIT_OFFSET";
-static char __pyx_k_compound_data_type_s[] = "compound data type: %s\n";
-static char __pyx_k_name_s_numpy_dtype_s[] = ": name = '%s', numpy dtype = %s\n";
-static char __pyx_k_Dimension_isunlimited[] = "_Dimension.isunlimited";
-static char __pyx_k_len_of_unsized_object[] = "len() of unsized object";
-static char __pyx_k_set_auto_maskandscale[] = "set_auto_maskandscale";
-static char __pyx_k_name_cannot_be_altered[] = "name cannot be altered";
-static char __pyx_k_size_cannot_be_altered[] = "size cannot be altered";
-static char __pyx_k_unlimited_dimensions_s[] = "unlimited dimensions: %s\n";
-static char __pyx_k_unsupported_time_units[] = "unsupported time units";
-static char __pyx_k_variables_dimensions_s[] = " variables(dimensions): %s\n";
-static char __pyx_k_least_significant_digit[] = "least_significant_digit";
-static char __pyx_k_no_since_in_unit_string[] = "no 'since' in unit_string";
-static char __pyx_k_shape_cannot_be_altered[] = "shape cannot be altered";
-static char __pyx_k_unlimited_name_s_size_s[] = " (unlimited): name = '%s', size = %s\n";
-static char __pyx_k_MFDataset___getattribute[] = "MFDataset.__getattribute__";
-static char __pyx_k_needsworkaround_issue485[] = "_needsworkaround_issue485";
-static char __pyx_k_unlimited_dimensions_s_2[] = "unlimited dimensions = %s\n";
-static char __pyx_k_has_nc_inq_format_extended[] = "__has_nc_inq_format_extended__";
-static char __pyx_k_s_not_a_valid_variable_name[] = "%s not a valid variable name";
-static char __pyx_k_dimensions_cannot_be_altered[] = "dimensions cannot be altered";
-static char __pyx_k_s_not_a_valid_dimension_name[] = "%s not a valid dimension name";
-static char __pyx_k_The_number_of_stored_elements[] = "The number of stored elements.";
-static char __pyx_k_mode_must_be_w_r_a_or_r_got_s[] = "mode must be 'w', 'r', 'a' or 'r+', got '%s'";
-static char __pyx_k_string_name_of_Group_instance[] = "string name of Group instance";
-static char __pyx_k_unrecognized_format_requested[] = "unrecognized format requested";
-static char __pyx_k_Users_jwhitaker_python_netcdf4[] = "/Users/jwhitaker/python/netcdf4-python.git/netCDF4/_netCDF4.pyx";
-static char __pyx_k_Variable___orthogonal_indexing[] = "Variable.__orthogonal_indexing__";
-static char __pyx_k_Variable_set_auto_maskandscale[] = "_Variable.set_auto_maskandscale";
-static char __pyx_k_filepath_method_not_enabled_To[] = "\nfilepath method not enabled. To enable, install Cython, make sure you have\nversion 4.1.2 or higher of the netcdf C lib, and rebuild netcdf4-python.";
-static char __pyx_k_path_shows_the_location_of_the[] = "`path` shows the location of the `netCDF4.Group` in\n the `netCDF4.Dataset` in a unix directory format (the names of groups in the\n hierarchy separated by backslashes). A `netCDF4.Dataset` instance is the root\n group, so the path is simply `'/'`.";
-static char __pyx_k_renameGroup_method_not_enabled[] = "\nrenameGroup method not enabled. To enable, install Cython, make sure you have\nversion 4.3.1 or higher of the netcdf C lib, and rebuild netcdf4-python.";
-static char __pyx_k_A_numpy_dtype_object_describing[] = "A numpy dtype object describing the\n variable's data type.";
-static char __pyx_k_A_string_describing_the_name_of[] = "A string describing the name of the `netCDF4.Group`.";
-static char __pyx_k_A_tuple_containing_the_names_of[] = "A tuple containing the names of the\n dimensions associated with this variable.";
-static char __pyx_k_Always_True_Indicates_to_client[] = "Always `True`. Indicates to client code\n that the object supports 'orthogonal indexing', which means that slices\n that are 1d arrays or lists slice along each dimension independently. This\n behavior is similar to Fortran or Matlab, but different than numpy.";
-static char __pyx_k_Class_for_reading_multi_file_ne[] = "\nClass for reading multi-file netCDF Datasets, making variables\nspanning multiple files appear as if they were in one file.\nDatasets must be in `NETCDF4_CLASSIC, NETCDF3_CLASSIC, NETCDF3_64BIT_OFFSET\nor NETCDF3_64BIT_DATA` format (`NETCDF4` Datasets won't work).\n\nAdapted from [pycdf](http://pysclint.sourceforge.net/pycdf) by Andre Gosselin.\n\nExample usage (See `netCDF4.MFDataset.__init__` for more details):\n\n :::python [...]
-static char __pyx_k_Class_providing_an_interface_to[] = "\nClass providing an interface to a MFDataset time Variable by imposing a unique common\ntime unit to all files. \n\nExample usage (See `netCDF4.MFTime.__init__` for more details):\n\n :::python\n >>> import numpy\n >>> f1 = Dataset(\"mftest_1.nc\",\"w\", format=\"NETCDF4_CLASSIC\")\n >>> f2 = Dataset(\"mftest_2.nc\",\"w\", format=\"NETCDF4_CLASSIC\")\n >>> f1.createDimension(\"time\",None)\n >>> f2.createDimensio [...]
-static char __pyx_k_FillValue_attribute_must_be_set[] = "_FillValue attribute must be set when variable is ";
-static char __pyx_k_The_vltypes_dictionary_maps_the[] = "The `vltypes` dictionary maps the names of\n variable-length types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the\n `netCDF4.VLType` class.";
-static char __pyx_k_Variable_object_no_longer_valid[] = "Variable object no longer valid";
-static char __pyx_k_Version_1_2_3_Introduction_netc[] = "\nVersion 1.2.3\n-------------\n- - - \n\nIntroduction\n============\n\nnetcdf4-python is a Python interface to the netCDF C library. \n\n[netCDF](http://www.unidata.ucar.edu/software/netcdf/) version 4 has many features\nnot found in earlier versions of the library and is implemented on top of\n[HDF5](http://www.hdfgroup.org/HDF5). This module can read and write\nfiles in both the new netCDF 4 and the old netCDF 3 format, and can [...]
-static char __pyx_k_assign_vlen_method_only_for_use[] = "_assign_vlen method only for use with VLEN variables";
-static char __pyx_k_cannot_set__FillValue_attribute[] = "cannot set _FillValue attribute for VLEN or compound variable";
-static char __pyx_k_cannot_specify_chunksizes_for_a[] = "cannot specify chunksizes for a contiguous dataset";
-static char __pyx_k_current_size_of_Dimension_calls[] = "current size of Dimension (calls `len` on Dimension instance)";
-static char __pyx_k_data_model_describes_the_netCDF[] = "`data_model` describes the netCDF\n data model version, one of `NETCDF3_CLASSIC`, `NETCDF4`,\n `NETCDF4_CLASSIC`, `NETCDF3_64BIT_OFFSET` or `NETCDF3_64BIT_DATA`.";
-static char __pyx_k_disk_format_describes_the_under[] = "`disk_format` describes the underlying\n file format, one of `NETCDF3`, `HDF5`, `HDF4`,\n `PNETCDF`, `DAP2`, `DAP4` or `UNDEFINED`. Only available if using\n netcdf C library version >= 4.3.1, otherwise will always return\n `UNDEFINED`.";
-static char __pyx_k_endian_keyword_argument_must_be[] = "'endian' keyword argument must be 'little','big' or 'native', got '%s'";
-static char __pyx_k_endian_ness_of_dtype_and_endian[] = "endian-ness of dtype and endian kwarg do not match, using endian kwarg";
-static char __pyx_k_file_format_does_not_support_NC[] = "file format does not support NC_STRING attributes";
-static char __pyx_k_get_variables_by_attribute_self[] = "\n**`get_variables_by_attribute(self, **kwargs)`**\n\nReturns a list of variables that match specific conditions.\n\nCan pass in key=value parameters and variables are returned that\ncontain all of the matches. For example, \n\n :::python\n >>> # Get variables with x-axis attribute.\n >>> vs = nc.get_variables_by_attributes(axis='X')\n >>> # Get variables with matching \"standard_name\" attribute\n >>> vs = nc.get_va [...]
-static char __pyx_k_get_variables_s_dimension_names[] = "get variables's dimension names";
-static char __pyx_k_illegal_data_type_for_attribute[] = "illegal data type for attribute, must be one of %s, got %s";
-static char __pyx_k_name_s_numpy_dtype_s_fields_val[] = ": name = '%s', numpy dtype = %s, fields/values =%s\n";
-static char __pyx_k_negative_reference_year_in_time[] = "negative reference year in time units, must be >= 1";
-static char __pyx_k_netcdf_time_variable_is_missing[] = "netcdf time variable is missing a 'units' attribute";
-static char __pyx_k_parent_is_a_reference_to_the_pa[] = "`parent` is a reference to the parent\n `netCDF4.Group` instance. `None` for the root group or `netCDF4.Dataset` instance";
-static char __pyx_k_s_is_one_of_the_reserved_attrib[] = "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead.";
-static char __pyx_k_same_as_data_model_retained_for[] = "same as `data_model`, retained for backwards compatibility.";
-static char __pyx_k_wrong_data_type_in_object_array[] = "wrong data type in object array: should be %s, got %s";
-static char __pyx_k_wrong_data_type_should_be_s_got[] = "wrong data type: should be %s, got %s";
-static char __pyx_k_zero_not_allowed_as_a_reference[] = "zero not allowed as a reference year, does not exist in Julian or Gregorian calendars";
-static char __pyx_k_A_numpy_integer_dtype_object_des[] = "A numpy integer dtype object describing the base type for the Enum.";
-static char __pyx_k_A_python_dictionary_describing_t[] = "A python dictionary describing the enum fields and values.";
-static char __pyx_k_A_tuple_with_the_current_shape_l[] = "A tuple with the current shape (length of all dimensions).";
-static char __pyx_k_Dataset_get_variables_by_attribu[] = "Dataset.get_variables_by_attributes (line 2490)";
-static char __pyx_k_Describes_the_power_of_ten_of_th[] = "Describes the power of ten of the \n smallest decimal place in the data the contains a reliable value. Data is\n truncated to this decimal place when it is assigned to the `netCDF4.Variable`\n instance. If `None`, the data is not truncated.";
-static char __pyx_k_Dimension_object_no_longer_valid[] = "Dimension object no longer valid";
-static char __pyx_k_If_True_child_Dimension_and_Vari[] = "If `True`, child Dimension and Variables objects only keep weak references to\n the parent Dataset or Group.";
-static char __pyx_k_If_True_data_is_automatically_co[] = "If True, data is automatically converted to/from masked \n arrays when missing values or fill values are present. Default is `True`, can be\n reset using `netCDF4.Variable.set_auto_mask` and `netCDF4.Variable.set_auto_maskandscale`\n methods.";
-static char __pyx_k_MFNetCDF4_only_works_with_NETCDF[] = "MFNetCDF4 only works with NETCDF3_* and NETCDF4_CLASSIC formatted files, not NETCDF4";
-static char __pyx_k_MFTime_requires_that_the_same_ti[] = "MFTime requires that the same time calendar is used by all files.";
-static char __pyx_k_MFTime_requires_that_the_time_va[] = "MFTime requires that the time variable in all files have a calendar attribute";
-static char __pyx_k_Return_the_number_of_stored_elem[] = "Return the number of stored elements.";
-static char __pyx_k_The_cmptypes_dictionary_maps_the[] = "The `cmptypes` dictionary maps the names of\n compound types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the\n `netCDF4.CompoundType` class.";
-static char __pyx_k_The_dimensions_dictionary_maps_t[] = "The `dimensions` dictionary maps the names of\n dimensions defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the\n `netCDF4.Dimension` class.";
-static char __pyx_k_The_enumtypes_dictionary_maps_th[] = "The `enumtypes` dictionary maps the names of\n Enum types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the\n `netCDF4.EnumType` class.";
-static char __pyx_k_The_groups_dictionary_maps_the_n[] = "The groups dictionary maps the names of groups created for\n this `netCDF4.Dataset` or `netCDF4.Group` to instances of the `netCDF4.Group` class (the\n `netCDF4.Dataset` class is simply a special case of the `netCDF4.Group` class which\n describes the root group in the netCDF4 file).";
-static char __pyx_k_The_number_of_variable_dimension[] = "The number of variable dimensions.";
-static char __pyx_k_The_variables_dictionary_maps_th[] = "The `variables` dictionary maps the names of variables\n defined for this `netCDF4.Dataset` or `netCDF4.Group` to instances of the `netCDF4.Variable`\n class.";
-static char __pyx_k_Unsupported_compound_type_elemen[] = "Unsupported compound type element";
-static char __pyx_k_Variable_least_significant_digit[] = "Variable.least_significant_digit";
-static char __pyx_k_Variable_length_strings_are_only[] = "Variable length strings are only supported for the NETCDF4 format. For other formats, consider using netCDF4.stringtochar to convert string arrays into character arrays with an additional dimension.";
-static char __pyx_k_WARNING_unsupported_Compound_typ[] = "WARNING: unsupported Compound type, skipping...";
-static char __pyx_k_WARNING_unsupported_Enum_type_sk[] = "WARNING: unsupported Enum type, skipping...";
-static char __pyx_k_WARNING_unsupported_VLEN_type_sk[] = "WARNING: unsupported VLEN type, skipping...";
-static char __pyx_k_WARNING_variable_s_has_unsupport[] = "WARNING: variable '%s' has unsupported compound datatype, skipping ..";
-static char __pyx_k_aggregation_variable_s_not_defin[] = "aggregation variable %s not defined in %s";
-static char __pyx_k_attribute_s_has_unsupported_data[] = "attribute %s has unsupported datatype";
-static char __pyx_k_cannot_assign_fill_value_for_mas[] = "cannot assign fill_value for masked array when missing_value attribute is not a scalar";
-static char __pyx_k_cannot_close_a_netCDF4_Group_onl[] = "cannot close a `netCDF4.Group` (only applies to Dataset)";
-static char __pyx_k_cannot_find_compound_type_in_thi[] = "cannot find compound type in this group or parent groups";
-static char __pyx_k_cannot_use_utc_offset_for_refere[] = "cannot use utc_offset for reference years <= 0";
-static char __pyx_k_cannot_using_file_globbing_for_r[] = "cannot using file globbing for remote (OPeNDAP) datasets";
-static char __pyx_k_chunksize_cannot_exceed_dimensio[] = "chunksize cannot exceed dimension size";
-static char __pyx_k_chunksizes_must_be_a_sequence_wi[] = "chunksizes must be a sequence with the same length as dimensions";
-static char __pyx_k_compound_field_of_an_unsupported[] = "compound field of an unsupported data type";
-static char __pyx_k_created_using_fill_value_keyword[] = "created (using fill_value keyword to createVariable)";
-static char __pyx_k_data_can_only_be_assigned_to_VLE[] = "data can only be assigned to VLEN variables using integer indices";
-static char __pyx_k_data_to_put_in_string_variable_m[] = "data to put in string variable must be an object array containing Python strings";
-static char __pyx_k_dimension_s_not_defined_in_group[] = "dimension %s not defined in group %s or any group in it's family tree";
-static char __pyx_k_diskless_mode_requires_netcdf_li[] = "diskless mode requires netcdf lib >= 4.2.1, you have %s";
-static char __pyx_k_dtype_must_string_or_unicode_S_o[] = "dtype must string or unicode ('S' or 'U')";
-static char __pyx_k_filling_on_default__FillValue_of[] = "filling on, default _FillValue of %s ignored\n";
-static char __pyx_k_find_current_sizes_of_all_variab[] = "find current sizes of all variable dimensions";
-static char __pyx_k_format_not_supported_by_python_i[] = "format not supported by python interface";
-static char __pyx_k_if_True_scale_factor_and_add_off[] = "if True, `scale_factor` and `add_offset` are\n applied. Default is `True`, can be reset using `netCDF4.Variable.set_auto_scale` and\n `netCDF4.Variable.set_auto_maskandscale` methods.";
-static char __pyx_k_illegal_primitive_data_type_must[] = "illegal primitive data type, must be one of %s, got %s";
-static char __pyx_k_invalid_scale_factor_or_add_offs[] = "invalid scale_factor or add_offset attribute, no unpacking done...";
-static char __pyx_k_masked_arrays_cannot_be_assigned[] = "masked arrays cannot be assigned by VLEN str slices";
-static char __pyx_k_master_dataset_s_does_not_have_a[] = "master dataset %s does not have a aggregation dimension";
-static char __pyx_k_negative_strides_not_allowed_whe[] = "negative strides not allowed when slicing MFVariable Variable instance";
-static char __pyx_k_numpy_data_type_for_primitive_da[] = "numpy data type (for primitive data types) or\n VLType/CompoundType/EnumType instance \n (for compound, vlen or enum data types)";
-static char __pyx_k_only_endian_native_allowed_for_N[] = "only endian='native' allowed for NETCDF3 files";
-static char __pyx_k_only_numpy_string_unicode_or_obj[] = "only numpy string, unicode or object arrays can be assigned to VLEN str var slices";
-static char __pyx_k_please_install_ordereddict_https[] = "please install ordereddict (https://pypi.python.org/pypi/ordereddict)";
-static char __pyx_k_root_group_s_data_model_file_for[] = "root group (%s data model, file format %s):\n";
-static char __pyx_k_size_of_data_array_does_not_conf[] = "size of data array does not conform to slice";
-static char __pyx_k_strides_must_all_be_1_for_string[] = "strides must all be 1 for string variables";
-static char __pyx_k_strides_must_all_be_1_for_vlen_v[] = "strides must all be 1 for vlen variables";
-static char __pyx_k_string_name_of_Dimension_instanc[] = "string name of Dimension instance";
-static char __pyx_k_string_name_of_Variable_instance[] = "string name of Variable instance";
-static char __pyx_k_to_assign_values_to_a_non_scalar[] = "to assign values to a non-scalar variable, use a slice";
-static char __pyx_k_to_retrieve_values_from_a_non_sc[] = "to retrieve values from a non-scalar variable, use slicing";
-static char __pyx_k_trying_to_assign_illegal_value_t[] = "trying to assign illegal value to Enum variable";
-static char __pyx_k_type_must_string_or_unicode_S_or[] = "type must string or unicode ('S' or 'U')";
-static char __pyx_k_unsupported_component_type_for_V[] = "unsupported component type for VLEN";
-static char __pyx_k_unsupported_datatype_specified_f[] = "unsupported datatype specified for VLEN";
-static char __pyx_k_variable_s_data_type_mismatch_be[] = "variable %s : data type mismatch between master %s (%s) and extension %s (%s)";
-static char __pyx_k_variable_s_dimensions_mismatch_b[] = "variable %s : dimensions mismatch between master %s (%s) and extension %s (%s)";
-static char __pyx_k_variable_s_rank_mismatch_between[] = "variable %s : rank mismatch between master %s (%s) and extension %s (%s)";
-static char __pyx_k_variable_s_shape_mismatch_betwee[] = "variable %s : shape mismatch between master %s (%s) and extension %s (%s)";
-static char __pyx_k_vlen_string_array_attributes_not[] = "vlen string array attributes not supported";
-static char __pyx_k_A_numpy_dtype_object_describing_2[] = "A numpy dtype object describing the compound data type.";
-static char __pyx_k_A_numpy_dtype_object_describing_3[] = "A numpy dtype object describing the component type for the VLEN.";
-static char __pyx_k_A_string_describing_the_name_of_2[] = "A string describing the name of the `netCDF4.Dimension` - used when creating a\n `netCDF4.Variable` instance with `netCDF4.Dataset.createVariable`.";
-static char __pyx_k_s_is_one_of_the_reserved_attrib_2[] = "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead.";
-static char __pyx_k_WARNING_variable_s_has_unsupport_2[] = "WARNING: variable '%s' has unsupported VLEN datatype, skipping ..";
-static char __pyx_k_WARNING_variable_s_has_unsupport_3[] = "WARNING: variable '%s' has unsupported Enum datatype, skipping ..";
-static char __pyx_k_WARNING_variable_s_has_unsupport_4[] = "WARNING: variable '%s' has unsupported datatype, skipping ..";
-static char __pyx_k_filling_on_default__FillValue_of_2[] = "filling on, default _FillValue of %s used\n";
-static char __pyx_k_master_dataset_s_does_not_have_a_2[] = "master dataset %s does not have any variables to aggregate";
-static char __pyx_k_numpy_data_type_for_primitive_da_2[] = "numpy data type (for primitive data types) or\n VLType/CompoundType/EnumType instance (for compound, vlen or enum\n data types).";
-static char __pyx_k_unsupported_datatype_specified_f_2[] = "unsupported datatype specified for Enum (must be integer)";
+static const char __pyx_k_[] = "\000";
+static const char __pyx_k_1[] = "1";
+static const char __pyx_k_O[] = "O";
+static const char __pyx_k_S[] = "S";
+static const char __pyx_k_U[] = "U";
+static const char __pyx_k_V[] = "V";
+static const char __pyx_k_a[] = "a";
+static const char __pyx_k_b[] = "b";
+static const char __pyx_k_d[] = "d";
+static const char __pyx_k_f[] = "f";
+static const char __pyx_k_i[] = "i";
+static const char __pyx_k_k[] = "k";
+static const char __pyx_k_n[] = "n";
+static const char __pyx_k_r[] = "r";
+static const char __pyx_k_s[] = "(%s)";
+static const char __pyx_k_t[] = "t";
+static const char __pyx_k_u[] = "u'";
+static const char __pyx_k_v[] = "v";
+static const char __pyx_k_w[] = "w";
+static const char __pyx_k_0m[] = "\033[0m";
+static const char __pyx_k_4m[] = " \033[4m";
+static const char __pyx_k_S1[] = "S1";
+static const char __pyx_k__2[] = "";
+static const char __pyx_k_as[] = "as";
+static const char __pyx_k_bs[] = "bs";
+static const char __pyx_k_dt[] = "dt";
+static const char __pyx_k_f4[] = "f4";
+static const char __pyx_k_f8[] = "f8";
+static const char __pyx_k_i0[] = "i0";
+static const char __pyx_k_i1[] = "i1";
+static const char __pyx_k_i2[] = "i2";
+static const char __pyx_k_i4[] = "i4";
+static const char __pyx_k_i8[] = "i8";
+static const char __pyx_k_id[] = "id";
+static const char __pyx_k_iu[] = "iu";
+static const char __pyx_k_ma[] = "ma";
+static const char __pyx_k_n1[] = "n1";
+static const char __pyx_k_nv[] = "nv";
+static const char __pyx_k_td[] = "td";
+static const char __pyx_k_u1[] = "u1";
+static const char __pyx_k_u2[] = "u2";
+static const char __pyx_k_u4[] = "u4";
+static const char __pyx_k_u8[] = "u8";
+static const char __pyx_k_ws[] = "ws";
+static const char __pyx_k__14[] = "<";
+static const char __pyx_k__15[] = ">";
+static const char __pyx_k__16[] = "/";
+static const char __pyx_k__19[] = "'";
+static const char __pyx_k__21[] = ", ";
+static const char __pyx_k__22[] = ",";
+static const char __pyx_k__24[] = ",)";
+static const char __pyx_k__25[] = ")";
+static const char __pyx_k__28[] = "__";
+static const char __pyx_k__36[] = "=";
+static const char __pyx_k__37[] = "|";
+static const char __pyx_k_all[] = "all";
+static const char __pyx_k_any[] = "any";
+static const char __pyx_k_arr[] = "arr";
+static const char __pyx_k_big[] = "big";
+static const char __pyx_k_cdf[] = "_cdf";
+static const char __pyx_k_cnt[] = "cnt";
+static const char __pyx_k_dat[] = "dat";
+static const char __pyx_k_day[] = "day";
+static const char __pyx_k_dim[] = "dim";
+static const char __pyx_k_doc[] = "__doc__";
+static const char __pyx_k_get[] = "_get";
+static const char __pyx_k_grp[] = "grp";
+static const char __pyx_k_idx[] = "idx";
+static const char __pyx_k_ind[] = "ind";
+static const char __pyx_k_key[] = "_key";
+static const char __pyx_k_len[] = "__len__";
+static const char __pyx_k_lst[] = "lst";
+static const char __pyx_k_msg[] = "msg";
+static const char __pyx_k_num[] = "num";
+static const char __pyx_k_pop[] = "pop";
+static const char __pyx_k_put[] = "put";
+static const char __pyx_k_r_2[] = "r+";
+static const char __pyx_k_r_3[] = "%r\n";
+static const char __pyx_k_r_s[] = "r+s";
+static const char __pyx_k_s_2[] = "s";
+static const char __pyx_k_s_s[] = " %s: %s\n";
+static const char __pyx_k_sta[] = "sta";
+static const char __pyx_k_str[] = "str";
+static const char __pyx_k_sum[] = "sum";
+static const char __pyx_k_sys[] = "sys";
+static const char __pyx_k_val[] = "val";
+static const char __pyx_k_var[] = "var";
+static const char __pyx_k_vid[] = "vid";
+static const char __pyx_k_zip[] = "zip";
+static const char __pyx_k_1_10[] = "1.10";
+static const char __pyx_k_args[] = "args";
+static const char __pyx_k_bool[] = "bool";
+static const char __pyx_k_cdfm[] = "cdfm";
+static const char __pyx_k_char[] = "char";
+static const char __pyx_k_copy[] = "copy";
+static const char __pyx_k_data[] = "data";
+static const char __pyx_k_date[] = "date";
+static const char __pyx_k_days[] = "days";
+static const char __pyx_k_dict[] = "__dict__";
+static const char __pyx_k_dims[] = "_dims";
+static const char __pyx_k_dset[] = "dset";
+static const char __pyx_k_elem[] = "elem";
+static const char __pyx_k_enum[] = "enum";
+static const char __pyx_k_f4_2[] = "<f4";
+static const char __pyx_k_f4_3[] = ">f4";
+static const char __pyx_k_find[] = "find";
+static const char __pyx_k_flat[] = "flat";
+static const char __pyx_k_glob[] = "glob";
+static const char __pyx_k_grps[] = "_grps";
+static const char __pyx_k_hour[] = "hour";
+static const char __pyx_k_http[] = "http";
+static const char __pyx_k_in1d[] = "in1d";
+static const char __pyx_k_init[] = "__init__";
+static const char __pyx_k_isMA[] = "isMA";
+static const char __pyx_k_item[] = "item";
+static const char __pyx_k_izip[] = "izip";
+static const char __pyx_k_join[] = "join";
+static const char __pyx_k_keys[] = "keys";
+static const char __pyx_k_kind[] = "kind";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_mask[] = "mask";
+static const char __pyx_k_mode[] = "mode";
+static const char __pyx_k_name[] = "name";
+static const char __pyx_k_ndim[] = "ndim";
+static const char __pyx_k_numv[] = "numv";
+static const char __pyx_k_part[] = "part";
+static const char __pyx_k_path[] = "path";
+static const char __pyx_k_pdoc[] = "__pdoc__";
+static const char __pyx_k_prod[] = "prod";
+static const char __pyx_k_repr[] = "__repr__";
+static const char __pyx_k_secs[] = "secs";
+static const char __pyx_k_self[] = "self";
+static const char __pyx_k_send[] = "send";
+static const char __pyx_k_size[] = "size";
+static const char __pyx_k_slen[] = "slen";
+static const char __pyx_k_step[] = "step";
+static const char __pyx_k_stop[] = "stop";
+static const char __pyx_k_strd[] = "strd";
+static const char __pyx_k_strt[] = "strt";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_tile[] = "tile";
+static const char __pyx_k_time[] = "time";
+static const char __pyx_k_toma[] = "_toma";
+static const char __pyx_k_unit[] = "unit";
+static const char __pyx_k_vars[] = "_vars";
+static const char __pyx_k_view[] = "view";
+static const char __pyx_k_vlen[] = "vlen";
+static const char __pyx_k_warn[] = "warn";
+static const char __pyx_k_year[] = "year";
+static const char __pyx_k_zlib[] = "zlib";
+static const char __pyx_k_1_2_4[] = "1.2.4";
+static const char __pyx_k_4_2_1[] = "4.2.1";
+static const char __pyx_k_4_4_0[] = "4.4.0";
+static const char __pyx_k_4_4_1[] = "4.4.1";
+static const char __pyx_k_align[] = "align";
+static const char __pyx_k_array[] = "array";
+static const char __pyx_k_ascii[] = "ascii";
+static const char __pyx_k_attrs[] = "attrs";
+static const char __pyx_k_atype[] = "atype";
+static const char __pyx_k_cdf_2[] = "cdf";
+static const char __pyx_k_check[] = "check";
+static const char __pyx_k_close[] = "close";
+static const char __pyx_k_count[] = "count";
+static const char __pyx_k_d_d_d[] = "%d.%d.%d";
+static const char __pyx_k_dates[] = "dates";
+static const char __pyx_k_dimid[] = "_dimid";
+static const char __pyx_k_dtype[] = "dtype";
+static const char __pyx_k_empty[] = "empty";
+static const char __pyx_k_exact[] = "exact";
+static const char __pyx_k_files[] = "files";
+static const char __pyx_k_float[] = "float";
+static const char __pyx_k_grp_2[] = "_grp";
+static const char __pyx_k_grpid[] = "_grpid";
+static const char __pyx_k_isnan[] = "isnan";
+static const char __pyx_k_items[] = "items";
+static const char __pyx_k_lower[] = "lower";
+static const char __pyx_k_month[] = "month";
+static const char __pyx_k_msecs[] = "msecs";
+static const char __pyx_k_names[] = "names";
+static const char __pyx_k_numpy[] = "numpy";
+static const char __pyx_k_proxy[] = "proxy";
+static const char __pyx_k_put_2[] = "_put";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_ravel[] = "ravel";
+static const char __pyx_k_redef[] = "_redef";
+static const char __pyx_k_round[] = "round";
+static const char __pyx_k_s_s_s[] = "%s %s(%s)\n";
+static const char __pyx_k_scale[] = "scale";
+static const char __pyx_k_shape[] = "shape";
+static const char __pyx_k_since[] = "since";
+static const char __pyx_k_split[] = "split";
+static const char __pyx_k_start[] = "start";
+static const char __pyx_k_strip[] = "strip";
+static const char __pyx_k_throw[] = "throw";
+static const char __pyx_k_times[] = "times";
+static const char __pyx_k_tostr[] = "_tostr";
+static const char __pyx_k_tsecs[] = "tsecs";
+static const char __pyx_k_units[] = "units";
+static const char __pyx_k_utf_8[] = "utf-8";
+static const char __pyx_k_utils[] = "utils";
+static const char __pyx_k_utime[] = "utime";
+static const char __pyx_k_vInst[] = "vInst";
+static const char __pyx_k_vName[] = "vName";
+static const char __pyx_k_value[] = "value";
+static const char __pyx_k_varid[] = "_varid";
+static const char __pyx_k_zeros[] = "zeros";
+static const char __pyx_k_MFTime[] = "MFTime";
+static const char __pyx_k_aggdim[] = "aggdim";
+static const char __pyx_k_append[] = "append";
+static const char __pyx_k_around[] = "around";
+static const char __pyx_k_astype[] = "astype";
+static const char __pyx_k_decode[] = "decode";
+static const char __pyx_k_dims_2[] = "dims";
+static const char __pyx_k_dset_2[] = "_dset";
+static const char __pyx_k_encode[] = "encode";
+static const char __pyx_k_enddef[] = "_enddef";
+static const char __pyx_k_endian[] = "endian";
+static const char __pyx_k_fields[] = "fields";
+static const char __pyx_k_filled[] = "filled";
+static const char __pyx_k_format[] = "format";
+static const char __pyx_k_groups[] = "groups";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_isenum[] = "_isenum";
+static const char __pyx_k_isvlen[] = "_isvlen";
+static const char __pyx_k_julian[] = "julian";
+static const char __pyx_k_little[] = "little";
+static const char __pyx_k_lstArr[] = "lstArr";
+static const char __pyx_k_master[] = "master";
+static const char __pyx_k_minute[] = "minute";
+static const char __pyx_k_module[] = "__module__";
+static const char __pyx_k_msecsd[] = "msecsd";
+static const char __pyx_k_name_2[] = "_name";
+static const char __pyx_k_native[] = "native";
+static const char __pyx_k_nbytes[] = "nbytes";
+static const char __pyx_k_ncdump[] = "ncdump";
+static const char __pyx_k_nctime[] = "nctime";
+static const char __pyx_k_nelems[] = "nelems";
+static const char __pyx_k_object[] = "object";
+static const char __pyx_k_parent[] = "parent";
+static const char __pyx_k_path_2[] = "_path";
+static const char __pyx_k_path_s[] = "path = %s\n";
+static const char __pyx_k_recLen[] = "_recLen";
+static const char __pyx_k_recVar[] = "_recVar";
+static const char __pyx_k_second[] = "second";
+static const char __pyx_k_select[] = "select";
+static const char __pyx_k_stride[] = "stride";
+static const char __pyx_k_string[] = "string";
+static const char __pyx_k_tolist[] = "tolist";
+static const char __pyx_k_typeid[] = "typeid";
+static const char __pyx_k_values[] = "values";
+static const char __pyx_k_vltype[] = "_vltype";
+static const char __pyx_k_IOError[] = "IOError";
+static const char __pyx_k_MINYEAR[] = "MINYEAR";
+static const char __pyx_k_NETCDF3[] = "NETCDF3";
+static const char __pyx_k_NETCDF4[] = "NETCDF4";
+static const char __pyx_k_asarray[] = "asarray";
+static const char __pyx_k_bytestr[] = "bytestr";
+static const char __pyx_k_cdfTLen[] = "_cdfTLen";
+static const char __pyx_k_cdfVLen[] = "_cdfVLen";
+static const char __pyx_k_cdftime[] = "cdftime";
+static const char __pyx_k_clobber[] = "clobber";
+static const char __pyx_k_cmptype[] = "_cmptype";
+static const char __pyx_k_d_d_d_s[] = "%d.%d.%d-%s";
+static const char __pyx_k_dimlens[] = "dimlens";
+static const char __pyx_k_dimname[] = "dimname";
+static const char __pyx_k_exclude[] = "exclude";
+static const char __pyx_k_extDims[] = "extDims";
+static const char __pyx_k_extType[] = "extType";
+static const char __pyx_k_files_2[] = "_files";
+static const char __pyx_k_flatten[] = "flatten";
+static const char __pyx_k_formats[] = "formats";
+static const char __pyx_k_genexpr[] = "genexpr";
+static const char __pyx_k_getattr[] = "__getattr__";
+static const char __pyx_k_getdims[] = "_getdims";
+static const char __pyx_k_getitem[] = "__getitem__";
+static const char __pyx_k_getname[] = "_getname";
+static const char __pyx_k_group_s[] = "group %s:\n";
+static const char __pyx_k_has_lsd[] = "_has_lsd";
+static const char __pyx_k_nc_type[] = "_nc_type";
+static const char __pyx_k_ncattrs[] = "ncattrs";
+static const char __pyx_k_newname[] = "newname";
+static const char __pyx_k_offsets[] = "offsets";
+static const char __pyx_k_oldname[] = "oldname";
+static const char __pyx_k_persist[] = "persist";
+static const char __pyx_k_prepare[] = "__prepare__";
+static const char __pyx_k_put_ind[] = "put_ind";
+static const char __pyx_k_python3[] = "python3";
+static const char __pyx_k_ref_num[] = "ref_num";
+static const char __pyx_k_replace[] = "replace";
+static const char __pyx_k_reshape[] = "reshape";
+static const char __pyx_k_s_s_s_2[] = "%s %s%s\n";
+static const char __pyx_k_seconds[] = "seconds";
+static const char __pyx_k_setattr[] = "__setattr__";
+static const char __pyx_k_shape_2[] = "_shape";
+static const char __pyx_k_shuffle[] = "shuffle";
+static const char __pyx_k_squeeze[] = "squeeze";
+static const char __pyx_k_timestr[] = "timestr";
+static const char __pyx_k_unicode[] = "__unicode__";
+static const char __pyx_k_value_2[] = "_value";
+static const char __pyx_k_varInfo[] = "varInfo";
+static const char __pyx_k_varname[] = "varname";
+static const char __pyx_k_version[] = "__version__";
+static const char __pyx_k_vltypes[] = "vltypes";
+static const char __pyx_k_weakref[] = "weakref";
+static const char __pyx_k_Ellipsis[] = "Ellipsis";
+static const char __pyx_k_KeyError[] = "KeyError";
+static const char __pyx_k_NUMCHARS[] = "NUMCHARS";
+static const char __pyx_k_Variable[] = "_Variable";
+static const char __pyx_k_aggDimId[] = "aggDimId";
+static const char __pyx_k_basedate[] = "basedate";
+static const char __pyx_k_byteswap[] = "byteswap";
+static const char __pyx_k_calendar[] = "calendar";
+static const char __pyx_k_cmptypes[] = "cmptypes";
+static const char __pyx_k_compound[] = "compound";
+static const char __pyx_k_datatype[] = "datatype";
+static const char __pyx_k_date2num[] = "date2num";
+static const char __pyx_k_datetime[] = "datetime";
+static const char __pyx_k_dimnames[] = "dimnames";
+static const char __pyx_k_diskless[] = "diskless";
+static const char __pyx_k_encoding[] = "encoding";
+static const char __pyx_k_endswith[] = "endswith";
+static const char __pyx_k_enumtype[] = "_enumtype";
+static const char __pyx_k_extShape[] = "extShape";
+static const char __pyx_k_filename[] = "filename";
+static const char __pyx_k_find_dim[] = "_find_dim";
+static const char __pyx_k_groups_s[] = " groups: %s\n";
+static const char __pyx_k_grpnames[] = "grpnames";
+static const char __pyx_k_has_cdf5[] = "__has_cdf5__";
+static const char __pyx_k_hr_units[] = "hr_units";
+static const char __pyx_k_ismasked[] = "ismasked";
+static const char __pyx_k_isscalar[] = "isscalar";
+static const char __pyx_k_itemsize[] = "itemsize";
+static const char __pyx_k_newSlice[] = "newSlice";
+static const char __pyx_k_normpath[] = "normpath";
+static const char __pyx_k_num2date[] = "num2date";
+static const char __pyx_k_qualname[] = "__qualname__";
+static const char __pyx_k_quantize[] = "_quantize";
+static const char __pyx_k_ref_date[] = "ref_date";
+static const char __pyx_k_standard[] = "standard";
+static const char __pyx_k_subdtype[] = "subdtype";
+static const char __pyx_k_to_ascii[] = "_to_ascii";
+static const char __pyx_k_tostring[] = "tostring";
+static const char __pyx_k_typecode[] = "typecode";
+static const char __pyx_k_varnames[] = "varnames";
+static const char __pyx_k_warnings[] = "warnings";
+static const char __pyx_k_Dimension[] = "_Dimension";
+static const char __pyx_k_FillValue[] = "_FillValue";
+static const char __pyx_k_MFDataset[] = "MFDataset";
+static const char __pyx_k_TypeError[] = "TypeError";
+static const char __pyx_k_UNDEFINED[] = "UNDEFINED";
+static const char __pyx_k_byteorder[] = "byteorder";
+static const char __pyx_k_cdfRecVar[] = "_cdfRecVar";
+static const char __pyx_k_cdfVLen_2[] = "cdfVLen";
+static const char __pyx_k_complevel[] = "complevel";
+static const char __pyx_k_datashape[] = "datashape";
+static const char __pyx_k_dateparse[] = "_dateparse";
+static const char __pyx_k_day_units[] = "day_units";
+static const char __pyx_k_delncattr[] = "delncattr";
+static const char __pyx_k_dimtotlen[] = "dimtotlen";
+static const char __pyx_k_enum_dict[] = "enum_dict";
+static const char __pyx_k_enumerate[] = "enumerate";
+static const char __pyx_k_enumtypes[] = "enumtypes";
+static const char __pyx_k_getncattr[] = "getncattr";
+static const char __pyx_k_gregorian[] = "gregorian";
+static const char __pyx_k_isostring[] = "isostring";
+static const char __pyx_k_iteritems[] = "iteritems";
+static const char __pyx_k_itertools[] = "itertools";
+static const char __pyx_k_majorvers[] = "majorvers";
+static const char __pyx_k_mastervar[] = "_mastervar";
+static const char __pyx_k_metaclass[] = "__metaclass__";
+static const char __pyx_k_min_units[] = "min_units";
+static const char __pyx_k_minorvers[] = "minorvers";
+static const char __pyx_k_nunlimdim[] = "_nunlimdim";
+static const char __pyx_k_posixpath[] = "posixpath";
+static const char __pyx_k_recdimlen[] = "recdimlen";
+static const char __pyx_k_sec_units[] = "sec_units";
+static const char __pyx_k_setncattr[] = "setncattr";
+static const char __pyx_k_timedelta[] = "timedelta";
+static const char __pyx_k_totaltime[] = "totaltime";
+static const char __pyx_k_traceback[] = "traceback";
+static const char __pyx_k_unlimdims[] = "unlimdims";
+static const char __pyx_k_variables[] = "variables";
+static const char __pyx_k_walk_grps[] = "_walk_grps";
+static const char __pyx_k_Group_name[] = "Group.name";
+static const char __pyx_k_IndexError[] = "IndexError";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_add_offset[] = "add_offset";
+static const char __pyx_k_aggDimName[] = "aggDimName";
+static const char __pyx_k_chunksizes[] = "chunksizes";
+static const char __pyx_k_contiguous[] = "contiguous";
+static const char __pyx_k_data_model[] = "data_model";
+static const char __pyx_k_date2index[] = "date2index";
+static const char __pyx_k_dimensions[] = "dimensions";
+static const char __pyx_k_dtype_name[] = "dtype_name";
+static const char __pyx_k_fill_value[] = "fill_value";
+static const char __pyx_k_filling_on[] = "filling on";
+static const char __pyx_k_fletcher32[] = "fletcher32";
+static const char __pyx_k_groups_s_2[] = " groups = %s\n";
+static const char __pyx_k_iscompound[] = "_iscompound";
+static const char __pyx_k_masterDims[] = "masterDims";
+static const char __pyx_k_masterType[] = "masterType";
+static const char __pyx_k_ncdump_var[] = "ncdump_var";
+static const char __pyx_k_nctonptype[] = "_nctonptype";
+static const char __pyx_k_netcdftime[] = "netcdftime";
+static const char __pyx_k_nptonctype[] = "_nptonctype";
+static const char __pyx_k_parse_date[] = "_parse_date";
+static const char __pyx_k_preemption[] = "preemption";
+static const char __pyx_k_recdimname[] = "recdimname";
+static const char __pyx_k_sortbylist[] = "_sortbylist";
+static const char __pyx_k_startswith[] = "startswith";
+static const char __pyx_k_time2index[] = "time2index";
+static const char __pyx_k_utc_offset[] = "utc_offset";
+static const char __pyx_k_ImportError[] = "ImportError";
+static const char __pyx_k_NC_DISKLESS[] = "NC_DISKLESS";
+static const char __pyx_k_OrderedDict[] = "OrderedDict";
+static const char __pyx_k_String_name[] = "String name.";
+static const char __pyx_k_VLType_name[] = "VLType.name";
+static const char __pyx_k_assign_vlen[] = "_assign_vlen";
+static const char __pyx_k_cdfRecVar_2[] = "cdfRecVar";
+static const char __pyx_k_chunk_cache[] = "chunk_cache";
+static const char __pyx_k_collections[] = "collections";
+static const char __pyx_k_concatenate[] = "concatenate";
+static const char __pyx_k_createGroup[] = "createGroup";
+static const char __pyx_k_development[] = "-development";
+static const char __pyx_k_disk_format[] = "_disk_format";
+static const char __pyx_k_file_format[] = "file_format";
+static const char __pyx_k_filling_off[] = "filling off\n";
+static const char __pyx_k_format_dict[] = "_format_dict";
+static const char __pyx_k_isprimitive[] = "_isprimitive";
+static const char __pyx_k_isunlimited[] = "isunlimited";
+static const char __pyx_k_keepweakref[] = "keepweakref";
+static const char __pyx_k_masterShape[] = "masterShape";
+static const char __pyx_k_ordereddict[] = "ordereddict";
+static const char __pyx_k_patchstring[] = "patchstring";
+static const char __pyx_k_releasevers[] = "releasevers";
+static const char __pyx_k_string_type[] = ": string type";
+static const char __pyx_k_stringtoarr[] = "stringtoarr";
+static const char __pyx_k_variables_s[] = " variables = %s\n";
+static const char __pyx_k_Dataset_path[] = "Dataset.path";
+static const char __pyx_k_MFTime__time[] = "_MFTime__time";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_UnicodeError[] = "UnicodeError";
+static const char __pyx_k_VLType_dtype[] = "VLType.dtype";
+static const char __pyx_k_chartostring[] = "chartostring";
+static const char __pyx_k_data_model_2[] = "_data_model";
+static const char __pyx_k_dimensions_s[] = " dimensions = %s\n";
+static const char __pyx_k_getattribute[] = "__getattribute__";
+static const char __pyx_k_masked_array[] = "masked_array";
+static const char __pyx_k_masterRecVar[] = "masterRecVar";
+static const char __pyx_k_microseconds[] = "microseconds";
+static const char __pyx_k_private_atts[] = "_private_atts";
+static const char __pyx_k_recdimname_2[] = "_recdimname";
+static const char __pyx_k_scale_factor[] = "scale_factor";
+static const char __pyx_k_stringtochar[] = "stringtochar";
+static const char __pyx_k_version_info[] = "version_info";
+static const char __pyx_k_EnumType_name[] = "EnumType.name";
+static const char __pyx_k_Illegal_index[] = "Illegal index";
+static const char __pyx_k_MFTime___init[] = "MFTime.__init__";
+static const char __pyx_k_MFTime__delta[] = "_MFTime__delta";
+static const char __pyx_k_NETCDF3_64BIT[] = "NETCDF3_64BIT";
+static const char __pyx_k_Variable_mask[] = "Variable.mask";
+static const char __pyx_k_Variable_name[] = "Variable.name";
+static const char __pyx_k_Variable_ndim[] = "Variable.ndim";
+static const char __pyx_k_Variable_size[] = "Variable.size";
+static const char __pyx_k_datatype_name[] = "datatype_name";
+static const char __pyx_k_disk_format_2[] = "disk_format";
+static const char __pyx_k_file_format_2[] = "_file_format";
+static const char __pyx_k_getlibversion[] = "getlibversion";
+static const char __pyx_k_intnptonctype[] = "_intnptonctype";
+static const char __pyx_k_is_native_big[] = "is_native_big";
+static const char __pyx_k_missing_value[] = "missing_value";
+static const char __pyx_k_name_s_size_s[] = ": name = '%s', size = %s\n";
+static const char __pyx_k_set_auto_mask[] = "set_auto_mask";
+static const char __pyx_k_timestr_split[] = "timestr_split";
+static const char __pyx_k_unicode_error[] = "unicode_error";
+static const char __pyx_k_AttributeError[] = "AttributeError";
+static const char __pyx_k_Dataset_groups[] = "Dataset.groups";
+static const char __pyx_k_Dataset_parent[] = "Dataset.parent";
+static const char __pyx_k_Dimension_name[] = "Dimension.name";
+static const char __pyx_k_EnumType_dtype[] = "EnumType.dtype";
+static const char __pyx_k_Variable___len[] = "_Variable.__len__";
+static const char __pyx_k_Variable_dtype[] = "Variable.dtype";
+static const char __pyx_k_Variable_scale[] = "Variable.scale";
+static const char __pyx_k_Variable_shape[] = "Variable.shape";
+static const char __pyx_k_current_size_s[] = "current size = %s\n";
+static const char __pyx_k_has_rename_grp[] = "__has_rename_grp__";
+static const char __pyx_k_hdf5libversion[] = "__hdf5libversion__";
+static const char __pyx_k_microsec_units[] = "microsec_units";
+static const char __pyx_k_millisec_units[] = "millisec_units";
+static const char __pyx_k_set_auto_scale[] = "set_auto_scale";
+static const char __pyx_k_supportedtypes[] = "_supportedtypes";
+static const char __pyx_k_Dataset_vltypes[] = "Dataset.vltypes";
+static const char __pyx_k_Dimension___len[] = "_Dimension.__len__";
+static const char __pyx_k_MFDataset_close[] = "MFDataset.close";
+static const char __pyx_k_NETCDF3_CLASSIC[] = "NETCDF3_CLASSIC";
+static const char __pyx_k_NETCDF4_CLASSIC[] = "NETCDF4_CLASSIC";
+static const char __pyx_k_Variable___init[] = "_Variable.__init__";
+static const char __pyx_k_Variable___repr[] = "_Variable.__repr__";
+static const char __pyx_k_Variable__shape[] = "_Variable._shape";
+static const char __pyx_k_current_shape_s[] = "current shape = %s\n";
+static const char __pyx_k_has_nc_inq_path[] = "__has_nc_inq_path__";
+static const char __pyx_k_out_array_shape[] = "_out_array_shape";
+static const char __pyx_k_Dataset_cmptypes[] = "Dataset.cmptypes";
+static const char __pyx_k_Dimension___init[] = "_Dimension.__init__";
+static const char __pyx_k_Dimension___repr[] = "_Dimension.__repr__";
+static const char __pyx_k_MFDataset___init[] = "MFDataset.__init__";
+static const char __pyx_k_MFDataset___repr[] = "MFDataset.__repr__";
+static const char __pyx_k_MFTime___getitem[] = "MFTime.__getitem__";
+static const char __pyx_k_StartCountStride[] = "_StartCountStride";
+static const char __pyx_k_Variable_ncattrs[] = "_Variable.ncattrs";
+static const char __pyx_k_default_encoding[] = "default_encoding";
+static const char __pyx_k_default_fillvals[] = "default_fillvals";
+static const char __pyx_k_enum_data_type_s[] = "enum data type: %s\n";
+static const char __pyx_k_is_native_little[] = "is_native_little";
+static const char __pyx_k_netCDF4__netCDF4[] = "netCDF4._netCDF4";
+static const char __pyx_k_s_not_found_in_s[] = "%s not found in %s";
+static const char __pyx_k_vlen_data_type_s[] = "vlen data type: %s\n";
+static const char __pyx_k_CompoundType_name[] = "CompoundType.name";
+static const char __pyx_k_Dataset_enumtypes[] = "Dataset.enumtypes";
+static const char __pyx_k_Dataset_variables[] = "Dataset.variables";
+static const char __pyx_k_MFDataset_ncattrs[] = "MFDataset.ncattrs";
+static const char __pyx_k_Variable_datatype[] = "Variable.datatype";
+static const char __pyx_k_Variable_typecode[] = "_Variable.typecode";
+static const char __pyx_k_gethdf5libversion[] = "_gethdf5libversion";
+static const char __pyx_k_netcdf4libversion[] = "__netcdf4libversion__";
+static const char __pyx_k_CompoundType_dtype[] = "CompoundType.dtype";
+static const char __pyx_k_Dataset_data_model[] = "Dataset.data_model";
+static const char __pyx_k_Dataset_dimensions[] = "Dataset.dimensions";
+static const char __pyx_k_EnumType_enum_dict[] = "EnumType.enum_dict";
+static const char __pyx_k_UnicodeDecodeError[] = "UnicodeDecodeError";
+static const char __pyx_k_Variable___getattr[] = "_Variable.__getattr__";
+static const char __pyx_k_Variable___getitem[] = "_Variable.__getitem__";
+static const char __pyx_k_dimensions_sizes_s[] = " dimensions(sizes): %s\n";
+static const char __pyx_k_set_default_format[] = "_set_default_format";
+static const char __pyx_k_Dataset_disk_format[] = "Dataset.disk_format";
+static const char __pyx_k_Dataset_file_format[] = "Dataset.file_format";
+static const char __pyx_k_Dataset_keepweakref[] = "Dataset.keepweakref";
+static const char __pyx_k_MFDataset___setattr[] = "MFDataset.__setattr__";
+static const char __pyx_k_Variable_dimensions[] = "Variable.dimensions";
+static const char __pyx_k_get_var_chunk_cache[] = "get_var_chunk_cache";
+static const char __pyx_k_orthogoral_indexing[] = "__orthogoral_indexing__";
+static const char __pyx_k_proleptic_gregorian[] = "proleptic_gregorian";
+static const char __pyx_k_reverse_format_dict[] = "_reverse_format_dict";
+static const char __pyx_k_NETCDF3_64BIT_OFFSET[] = "NETCDF3_64BIT_OFFSET";
+static const char __pyx_k_compound_data_type_s[] = "compound data type: %s\n";
+static const char __pyx_k_name_s_numpy_dtype_s[] = ": name = '%s', numpy dtype = %s\n";
+static const char __pyx_k_Dimension_isunlimited[] = "_Dimension.isunlimited";
+static const char __pyx_k_len_of_unsized_object[] = "len() of unsized object";
+static const char __pyx_k_set_auto_maskandscale[] = "set_auto_maskandscale";
+static const char __pyx_k_name_cannot_be_altered[] = "name cannot be altered";
+static const char __pyx_k_size_cannot_be_altered[] = "size cannot be altered";
+static const char __pyx_k_unlimited_dimensions_s[] = "unlimited dimensions: %s\n";
+static const char __pyx_k_unsupported_time_units[] = "unsupported time units";
+static const char __pyx_k_variables_dimensions_s[] = " variables(dimensions): %s\n";
+static const char __pyx_k_least_significant_digit[] = "least_significant_digit";
+static const char __pyx_k_no_since_in_unit_string[] = "no 'since' in unit_string";
+static const char __pyx_k_shape_cannot_be_altered[] = "shape cannot be altered";
+static const char __pyx_k_unlimited_name_s_size_s[] = " (unlimited): name = '%s', size = %s\n";
+static const char __pyx_k_MFDataset___getattribute[] = "MFDataset.__getattribute__";
+static const char __pyx_k_needsworkaround_issue485[] = "_needsworkaround_issue485";
+static const char __pyx_k_unlimited_dimensions_s_2[] = "unlimited dimensions = %s\n";
+static const char __pyx_k_has_nc_inq_format_extended[] = "__has_nc_inq_format_extended__";
+static const char __pyx_k_s_not_a_valid_variable_name[] = "%s not a valid variable name";
+static const char __pyx_k_dimensions_cannot_be_altered[] = "dimensions cannot be altered";
+static const char __pyx_k_s_not_a_valid_dimension_name[] = "%s not a valid dimension name";
+static const char __pyx_k_The_number_of_stored_elements[] = "The number of stored elements.";
+static const char __pyx_k_mode_must_be_w_r_a_or_r_got_s[] = "mode must be 'w', 'r', 'a' or 'r+', got '%s'";
+static const char __pyx_k_unrecognized_format_requested[] = "unrecognized format requested";
+static const char __pyx_k_Variable___orthogonal_indexing[] = "Variable.__orthogonal_indexing__";
+static const char __pyx_k_Variable_set_auto_maskandscale[] = "_Variable.set_auto_maskandscale";
+static const char __pyx_k_WARNING_Backwards_incompatible[] = "\nWARNING: Backwards incompatible files will be created with HDF5 1.10.x \nand netCDF < 4.4.1. Upgrading to netCDF4 >= 4.4.1 or downgrading to \nto HDF5 version 1.8.x is highly recommended \n(see https://github.com/Unidata/netcdf-c/issues/250).";
+static const char __pyx_k_filepath_method_not_enabled_To[] = "\nfilepath method not enabled. To enable, install Cython, make sure you have\nversion 4.1.2 or higher of the netcdf C lib, and rebuild netcdf4-python.";
+static const char __pyx_k_path_shows_the_location_of_the[] = "`path` shows the location of the `netCDF4.Group` in\n the `netCDF4.Dataset` in a unix directory format (the names of groups in the\n hierarchy separated by backslashes). A `netCDF4.Dataset` instance is the root\n group, so the path is simply `'/'`.";
+static const char __pyx_k_renameGroup_method_not_enabled[] = "\nrenameGroup method not enabled. To enable, install Cython, make sure you have\nversion 4.3.1 or higher of the netcdf C lib, and rebuild netcdf4-python.";
+static const char __pyx_k_A_numpy_dtype_object_describing[] = "A numpy dtype object describing the\n variable's data type.";
+static const char __pyx_k_A_string_describing_the_name_of[] = "A string describing the name of the `netCDF4.Group`.";
+static const char __pyx_k_A_tuple_containing_the_names_of[] = "A tuple containing the names of the\n dimensions associated with this variable.";
+static const char __pyx_k_Always_True_Indicates_to_client[] = "Always `True`. Indicates to client code\n that the object supports 'orthogonal indexing', which means that slices\n that are 1d arrays or lists slice along each dimension independently. This\n behavior is similar to Fortran or Matlab, but different than numpy.";
+static const char __pyx_k_Class_for_reading_multi_file_ne[] = "\nClass for reading multi-file netCDF Datasets, making variables\nspanning multiple files appear as if they were in one file.\nDatasets must be in `NETCDF4_CLASSIC, NETCDF3_CLASSIC, NETCDF3_64BIT_OFFSET\nor NETCDF3_64BIT_DATA` format (`NETCDF4` Datasets won't work).\n\nAdapted from [pycdf](http://pysclint.sourceforge.net/pycdf) by Andre Gosselin.\n\nExample usage (See `netCDF4.MFDataset.__init__` for more details):\n\n ::: [...]
+static const char __pyx_k_Class_providing_an_interface_to[] = "\nClass providing an interface to a MFDataset time Variable by imposing a unique common\ntime unit to all files. \n\nExample usage (See `netCDF4.MFTime.__init__` for more details):\n\n :::python\n >>> import numpy\n >>> f1 = Dataset(\"mftest_1.nc\",\"w\", format=\"NETCDF4_CLASSIC\")\n >>> f2 = Dataset(\"mftest_2.nc\",\"w\", format=\"NETCDF4_CLASSIC\")\n >>> f1.createDimension(\"time\",None)\n >>> f2.createDi [...]
+static const char __pyx_k_FillValue_attribute_must_be_set[] = "_FillValue attribute must be set when variable is ";
+static const char __pyx_k_The_vltypes_dictionary_maps_the[] = "The `vltypes` dictionary maps the names of\n variable-length types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the\n `netCDF4.VLType` class.";
+static const char __pyx_k_Variable_object_no_longer_valid[] = "Variable object no longer valid";
+static const char __pyx_k_Version_1_2_4_Introduction_netc[] = "\nVersion 1.2.4\n-------------\n- - - \n\nIntroduction\n============\n\nnetcdf4-python is a Python interface to the netCDF C library. \n\n[netCDF](http://www.unidata.ucar.edu/software/netcdf/) version 4 has many features\nnot found in earlier versions of the library and is implemented on top of\n[HDF5](http://www.hdfgroup.org/HDF5). This module can read and write\nfiles in both the new netCDF 4 and the old netCDF 3 format, a [...]
+static const char __pyx_k_assign_vlen_method_only_for_use[] = "_assign_vlen method only for use with VLEN variables";
+static const char __pyx_k_cannot_set__FillValue_attribute[] = "cannot set _FillValue attribute for VLEN or compound variable";
+static const char __pyx_k_cannot_specify_chunksizes_for_a[] = "cannot specify chunksizes for a contiguous dataset";
+static const char __pyx_k_data_model_describes_the_netCDF[] = "`data_model` describes the netCDF\n data model version, one of `NETCDF3_CLASSIC`, `NETCDF4`,\n `NETCDF4_CLASSIC`, `NETCDF3_64BIT_OFFSET` or `NETCDF3_64BIT_DATA`.";
+static const char __pyx_k_disk_format_describes_the_under[] = "`disk_format` describes the underlying\n file format, one of `NETCDF3`, `HDF5`, `HDF4`,\n `PNETCDF`, `DAP2`, `DAP4` or `UNDEFINED`. Only available if using\n netcdf C library version >= 4.3.1, otherwise will always return\n `UNDEFINED`.";
+static const char __pyx_k_endian_keyword_argument_must_be[] = "'endian' keyword argument must be 'little','big' or 'native', got '%s'";
+static const char __pyx_k_endian_ness_of_dtype_and_endian[] = "endian-ness of dtype and endian kwarg do not match, using endian kwarg";
+static const char __pyx_k_file_format_does_not_support_NC[] = "file format does not support NC_STRING attributes";
+static const char __pyx_k_get_variables_by_attribute_self[] = "\n**`get_variables_by_attribute(self, **kwargs)`**\n\nReturns a list of variables that match specific conditions.\n\nCan pass in key=value parameters and variables are returned that\ncontain all of the matches. For example, \n\n :::python\n >>> # Get variables with x-axis attribute.\n >>> vs = nc.get_variables_by_attributes(axis='X')\n >>> # Get variables with matching \"standard_name\" attribute\n >>> vs = nc. [...]
+static const char __pyx_k_illegal_data_type_for_attribute[] = "illegal data type for attribute, must be one of %s, got %s";
+static const char __pyx_k_name_s_numpy_dtype_s_fields_val[] = ": name = '%s', numpy dtype = %s, fields/values =%s\n";
+static const char __pyx_k_negative_reference_year_in_time[] = "negative reference year in time units, must be >= 1";
+static const char __pyx_k_netcdf_time_variable_is_missing[] = "netcdf time variable is missing a 'units' attribute";
+static const char __pyx_k_parent_is_a_reference_to_the_pa[] = "`parent` is a reference to the parent\n `netCDF4.Group` instance. `None` for the root group or `netCDF4.Dataset` instance";
+static const char __pyx_k_private_tmp_netcdf4_python_netC[] = "/private/tmp/netcdf4-python/netCDF4/_netCDF4.pyx";
+static const char __pyx_k_s_is_one_of_the_reserved_attrib[] = "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead.";
+static const char __pyx_k_same_as_data_model_retained_for[] = "same as `data_model`, retained for backwards compatibility.";
+static const char __pyx_k_wrong_data_type_in_object_array[] = "wrong data type in object array: should be %s, got %s";
+static const char __pyx_k_wrong_data_type_should_be_s_got[] = "wrong data type: should be %s, got %s";
+static const char __pyx_k_zero_not_allowed_as_a_reference[] = "zero not allowed as a reference year, does not exist in Julian or Gregorian calendars";
+static const char __pyx_k_A_numpy_integer_dtype_object_des[] = "A numpy integer dtype object describing the base type for the Enum.";
+static const char __pyx_k_A_python_dictionary_describing_t[] = "A python dictionary describing the enum fields and values.";
+static const char __pyx_k_A_tuple_with_the_current_shape_l[] = "A tuple with the current shape (length of all dimensions).";
+static const char __pyx_k_Dataset_get_variables_by_attribu[] = "Dataset.get_variables_by_attributes (line 2500)";
+static const char __pyx_k_Describes_the_power_of_ten_of_th[] = "Describes the power of ten of the \n smallest decimal place in the data the contains a reliable value. Data is\n truncated to this decimal place when it is assigned to the `netCDF4.Variable`\n instance. If `None`, the data is not truncated.";
+static const char __pyx_k_Dimension_object_no_longer_valid[] = "Dimension object no longer valid";
+static const char __pyx_k_If_True_child_Dimension_and_Vari[] = "If `True`, child Dimension and Variables objects only keep weak references to\n the parent Dataset or Group.";
+static const char __pyx_k_If_True_data_is_automatically_co[] = "If True, data is automatically converted to/from masked \n arrays when missing values or fill values are present. Default is `True`, can be\n reset using `netCDF4.Variable.set_auto_mask` and `netCDF4.Variable.set_auto_maskandscale`\n methods.";
+static const char __pyx_k_MFNetCDF4_only_works_with_NETCDF[] = "MFNetCDF4 only works with NETCDF3_* and NETCDF4_CLASSIC formatted files, not NETCDF4";
+static const char __pyx_k_MFTime_requires_that_the_same_ti[] = "MFTime requires that the same time calendar is used by all files.";
+static const char __pyx_k_MFTime_requires_that_the_time_va[] = "MFTime requires that the time variable in all files have a calendar attribute";
+static const char __pyx_k_The_cmptypes_dictionary_maps_the[] = "The `cmptypes` dictionary maps the names of\n compound types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the\n `netCDF4.CompoundType` class.";
+static const char __pyx_k_The_dimensions_dictionary_maps_t[] = "The `dimensions` dictionary maps the names of\n dimensions defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the\n `netCDF4.Dimension` class.";
+static const char __pyx_k_The_enumtypes_dictionary_maps_th[] = "The `enumtypes` dictionary maps the names of\n Enum types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the\n `netCDF4.EnumType` class.";
+static const char __pyx_k_The_groups_dictionary_maps_the_n[] = "The groups dictionary maps the names of groups created for\n this `netCDF4.Dataset` or `netCDF4.Group` to instances of the `netCDF4.Group` class (the\n `netCDF4.Dataset` class is simply a special case of the `netCDF4.Group` class which\n describes the root group in the netCDF4 file).";
+static const char __pyx_k_The_number_of_variable_dimension[] = "The number of variable dimensions.";
+static const char __pyx_k_The_variables_dictionary_maps_th[] = "The `variables` dictionary maps the names of variables\n defined for this `netCDF4.Dataset` or `netCDF4.Group` to instances of the `netCDF4.Variable`\n class.";
+static const char __pyx_k_Unsupported_compound_type_elemen[] = "Unsupported compound type element";
+static const char __pyx_k_Variable_least_significant_digit[] = "Variable.least_significant_digit";
+static const char __pyx_k_Variable_length_strings_are_only[] = "Variable length strings are only supported for the NETCDF4 format. For other formats, consider using netCDF4.stringtochar to convert string arrays into character arrays with an additional dimension.";
+static const char __pyx_k_WARNING_unsupported_Compound_typ[] = "WARNING: unsupported Compound type, skipping...";
+static const char __pyx_k_WARNING_unsupported_Enum_type_sk[] = "WARNING: unsupported Enum type, skipping...";
+static const char __pyx_k_WARNING_unsupported_VLEN_type_sk[] = "WARNING: unsupported VLEN type, skipping...";
+static const char __pyx_k_WARNING_variable_s_has_unsupport[] = "WARNING: variable '%s' has unsupported compound datatype, skipping ..";
+static const char __pyx_k_aggregation_variable_s_not_defin[] = "aggregation variable %s not defined in %s";
+static const char __pyx_k_attribute_s_has_unsupported_data[] = "attribute %s has unsupported datatype";
+static const char __pyx_k_cannot_assign_fill_value_for_mas[] = "cannot assign fill_value for masked array when missing_value attribute is not a scalar";
+static const char __pyx_k_cannot_close_a_netCDF4_Group_onl[] = "cannot close a `netCDF4.Group` (only applies to Dataset)";
+static const char __pyx_k_cannot_find_compound_type_in_thi[] = "cannot find compound type in this group or parent groups";
+static const char __pyx_k_cannot_use_utc_offset_for_refere[] = "cannot use utc_offset for reference years <= 0";
+static const char __pyx_k_cannot_using_file_globbing_for_r[] = "cannot using file globbing for remote (OPeNDAP) datasets";
+static const char __pyx_k_chunksize_cannot_exceed_dimensio[] = "chunksize cannot exceed dimension size";
+static const char __pyx_k_chunksizes_must_be_a_sequence_wi[] = "chunksizes must be a sequence with the same length as dimensions";
+static const char __pyx_k_compound_field_of_an_unsupported[] = "compound field of an unsupported data type";
+static const char __pyx_k_created_using_fill_value_keyword[] = "created (using fill_value keyword to createVariable)";
+static const char __pyx_k_data_can_only_be_assigned_to_VLE[] = "data can only be assigned to VLEN variables using integer indices";
+static const char __pyx_k_data_to_put_in_string_variable_m[] = "data to put in string variable must be an object array containing Python strings";
+static const char __pyx_k_dimension_s_not_defined_in_group[] = "dimension %s not defined in group %s or any group in it's family tree";
+static const char __pyx_k_diskless_mode_requires_netcdf_li[] = "diskless mode requires netcdf lib >= 4.2.1, you have %s";
+static const char __pyx_k_dtype_must_string_or_unicode_S_o[] = "dtype must string or unicode ('S' or 'U')";
+static const char __pyx_k_filling_on_default__FillValue_of[] = "filling on, default _FillValue of %s ignored\n";
+static const char __pyx_k_format_not_supported_by_python_i[] = "format not supported by python interface";
+static const char __pyx_k_if_True_scale_factor_and_add_off[] = "if True, `scale_factor` and `add_offset` are\n applied. Default is `True`, can be reset using `netCDF4.Variable.set_auto_scale` and\n `netCDF4.Variable.set_auto_maskandscale` methods.";
+static const char __pyx_k_illegal_primitive_data_type_must[] = "illegal primitive data type, must be one of %s, got %s";
+static const char __pyx_k_invalid_scale_factor_or_add_offs[] = "invalid scale_factor or add_offset attribute, no unpacking done...";
+static const char __pyx_k_masked_arrays_cannot_be_assigned[] = "masked arrays cannot be assigned by VLEN str slices";
+static const char __pyx_k_master_dataset_s_does_not_have_a[] = "master dataset %s does not have a aggregation dimension";
+static const char __pyx_k_negative_strides_not_allowed_whe[] = "negative strides not allowed when slicing MFVariable Variable instance";
+static const char __pyx_k_numpy_data_type_for_primitive_da[] = "numpy data type (for primitive data types) or\n VLType/CompoundType/EnumType instance (for compound, vlen or enum\n data types).";
+static const char __pyx_k_only_endian_native_allowed_for_N[] = "only endian='native' allowed for NETCDF3 files";
+static const char __pyx_k_only_numpy_string_unicode_or_obj[] = "only numpy string, unicode or object arrays can be assigned to VLEN str var slices";
+static const char __pyx_k_please_install_ordereddict_https[] = "please install ordereddict (https://pypi.python.org/pypi/ordereddict)";
+static const char __pyx_k_root_group_s_data_model_file_for[] = "root group (%s data model, file format %s):\n";
+static const char __pyx_k_size_of_data_array_does_not_conf[] = "size of data array does not conform to slice";
+static const char __pyx_k_strides_must_all_be_1_for_string[] = "strides must all be 1 for string variables";
+static const char __pyx_k_strides_must_all_be_1_for_vlen_v[] = "strides must all be 1 for vlen variables";
+static const char __pyx_k_to_assign_values_to_a_non_scalar[] = "to assign values to a non-scalar variable, use a slice";
+static const char __pyx_k_to_retrieve_values_from_a_non_sc[] = "to retrieve values from a non-scalar variable, use slicing";
+static const char __pyx_k_trying_to_assign_illegal_value_t[] = "trying to assign illegal value to Enum variable";
+static const char __pyx_k_type_must_string_or_unicode_S_or[] = "type must string or unicode ('S' or 'U')";
+static const char __pyx_k_unsupported_component_type_for_V[] = "unsupported component type for VLEN";
+static const char __pyx_k_unsupported_datatype_specified_f[] = "unsupported datatype specified for VLEN";
+static const char __pyx_k_variable_s_data_type_mismatch_be[] = "variable %s : data type mismatch between master %s (%s) and extension %s (%s)";
+static const char __pyx_k_variable_s_dimensions_mismatch_b[] = "variable %s : dimensions mismatch between master %s (%s) and extension %s (%s)";
+static const char __pyx_k_variable_s_rank_mismatch_between[] = "variable %s : rank mismatch between master %s (%s) and extension %s (%s)";
+static const char __pyx_k_variable_s_shape_mismatch_betwee[] = "variable %s : shape mismatch between master %s (%s) and extension %s (%s)";
+static const char __pyx_k_vlen_string_array_attributes_not[] = "vlen string array attributes not supported";
+static const char __pyx_k_A_numpy_dtype_object_describing_2[] = "A numpy dtype object describing the compound data type.";
+static const char __pyx_k_A_numpy_dtype_object_describing_3[] = "A numpy dtype object describing the component type for the VLEN.";
+static const char __pyx_k_A_string_describing_the_name_of_2[] = "A string describing the name of the `netCDF4.Dimension` - used when creating a\n `netCDF4.Variable` instance with `netCDF4.Dataset.createVariable`.";
+static const char __pyx_k_s_is_one_of_the_reserved_attrib_2[] = "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead.";
+static const char __pyx_k_WARNING_variable_s_has_unsupport_2[] = "WARNING: variable '%s' has unsupported VLEN datatype, skipping ..";
+static const char __pyx_k_WARNING_variable_s_has_unsupport_3[] = "WARNING: variable '%s' has unsupported Enum datatype, skipping ..";
+static const char __pyx_k_WARNING_variable_s_has_unsupport_4[] = "WARNING: variable '%s' has unsupported datatype, skipping ..";
+static const char __pyx_k_filling_on_default__FillValue_of_2[] = "filling on, default _FillValue of %s used\n";
+static const char __pyx_k_master_dataset_s_does_not_have_a_2[] = "master dataset %s does not have any variables to aggregate";
+static const char __pyx_k_unsupported_datatype_specified_f_2[] = "unsupported datatype specified for Enum (must be integer)";
static PyObject *__pyx_kp_s_;
static PyObject *__pyx_kp_s_0m;
static PyObject *__pyx_kp_s_1;
-static PyObject *__pyx_kp_s_1_2_3;
+static PyObject *__pyx_kp_s_1_10;
+static PyObject *__pyx_kp_s_1_2_4;
static PyObject *__pyx_kp_s_4_2_1;
static PyObject *__pyx_kp_s_4_4_0;
+static PyObject *__pyx_kp_s_4_4_1;
static PyObject *__pyx_kp_s_4m;
static PyObject *__pyx_kp_s_A_numpy_dtype_object_describing;
static PyObject *__pyx_kp_s_A_numpy_dtype_object_describing_2;
@@ -2034,7 +2197,6 @@ static PyObject *__pyx_kp_s_EnumType_name;
static PyObject *__pyx_n_s_FillValue;
static PyObject *__pyx_kp_s_FillValue_attribute_must_be_set;
static PyObject *__pyx_kp_s_Group_name;
-static PyObject *__pyx_n_s_HDF4;
static PyObject *__pyx_n_s_IOError;
static PyObject *__pyx_kp_s_If_True_child_Dimension_and_Vari;
static PyObject *__pyx_kp_s_If_True_data_is_automatically_co;
@@ -2087,7 +2249,6 @@ static PyObject *__pyx_n_s_UNDEFINED;
static PyObject *__pyx_n_s_UnicodeDecodeError;
static PyObject *__pyx_n_s_UnicodeError;
static PyObject *__pyx_kp_s_Unsupported_compound_type_elemen;
-static PyObject *__pyx_kp_s_Users_jwhitaker_python_netcdf4;
static PyObject *__pyx_n_s_V;
static PyObject *__pyx_kp_s_VLType_dtype;
static PyObject *__pyx_kp_s_VLType_name;
@@ -2115,6 +2276,7 @@ static PyObject *__pyx_n_s_Variable_set_auto_maskandscale;
static PyObject *__pyx_kp_s_Variable_shape;
static PyObject *__pyx_kp_s_Variable_size;
static PyObject *__pyx_n_s_Variable_typecode;
+static PyObject *__pyx_kp_s_WARNING_Backwards_incompatible;
static PyObject *__pyx_kp_s_WARNING_unsupported_Compound_typ;
static PyObject *__pyx_kp_s_WARNING_unsupported_Enum_type_sk;
static PyObject *__pyx_kp_s_WARNING_unsupported_VLEN_type_sk;
@@ -2454,7 +2616,7 @@ static PyObject *__pyx_n_s_nptonctype;
static PyObject *__pyx_n_s_num;
static PyObject *__pyx_n_s_num2date;
static PyObject *__pyx_n_s_numpy;
-static PyObject *__pyx_kp_s_numpy_data_type_for_primitive_da_2;
+static PyObject *__pyx_kp_s_numpy_data_type_for_primitive_da;
static PyObject *__pyx_n_s_numv;
static PyObject *__pyx_n_s_nunlimdim;
static PyObject *__pyx_n_s_nv;
@@ -2483,6 +2645,7 @@ static PyObject *__pyx_n_s_posixpath;
static PyObject *__pyx_n_s_preemption;
static PyObject *__pyx_n_s_prepare;
static PyObject *__pyx_n_s_private_atts;
+static PyObject *__pyx_kp_s_private_tmp_netcdf4_python_netC;
static PyObject *__pyx_n_s_prod;
static PyObject *__pyx_n_s_proleptic_gregorian;
static PyObject *__pyx_n_s_proxy;
@@ -2959,6 +3122,7 @@ static PyObject *__pyx_int_1;
static PyObject *__pyx_int_2;
static PyObject *__pyx_int_3;
static PyObject *__pyx_int_4;
+static PyObject *__pyx_int_5;
static PyObject *__pyx_int_6;
static PyObject *__pyx_int_8;
static PyObject *__pyx_int_10;
@@ -2983,23 +3147,24 @@ static PyObject *__pyx_slice__39;
static PyObject *__pyx_slice__40;
static PyObject *__pyx_slice__45;
static PyObject *__pyx_slice__46;
-static PyObject *__pyx_slice__53;
static PyObject *__pyx_slice__54;
+static PyObject *__pyx_slice__55;
+static PyObject *__pyx_slice__56;
static PyObject *__pyx_slice__57;
-static PyObject *__pyx_slice__58;
-static PyObject *__pyx_slice__64;
+static PyObject *__pyx_slice__62;
+static PyObject *__pyx_slice__65;
static PyObject *__pyx_slice__67;
+static PyObject *__pyx_slice__68;
static PyObject *__pyx_slice__69;
-static PyObject *__pyx_slice__70;
-static PyObject *__pyx_slice__71;
+static PyObject *__pyx_slice__73;
+static PyObject *__pyx_slice__76;
+static PyObject *__pyx_slice__77;
static PyObject *__pyx_slice__81;
-static PyObject *__pyx_slice__84;
-static PyObject *__pyx_slice__85;
+static PyObject *__pyx_slice__83;
static PyObject *__pyx_slice__88;
-static PyObject *__pyx_slice__90;
-static PyObject *__pyx_slice__95;
-static PyObject *__pyx_slice__96;
-static PyObject *__pyx_slice__99;
+static PyObject *__pyx_slice__89;
+static PyObject *__pyx_slice__92;
+static PyObject *__pyx_slice__93;
static PyObject *__pyx_tuple__10;
static PyObject *__pyx_tuple__17;
static PyObject *__pyx_tuple__18;
@@ -3025,136 +3190,130 @@ static PyObject *__pyx_tuple__49;
static PyObject *__pyx_tuple__50;
static PyObject *__pyx_tuple__51;
static PyObject *__pyx_tuple__52;
-static PyObject *__pyx_tuple__55;
-static PyObject *__pyx_tuple__56;
+static PyObject *__pyx_tuple__53;
+static PyObject *__pyx_tuple__58;
static PyObject *__pyx_tuple__59;
static PyObject *__pyx_tuple__60;
static PyObject *__pyx_tuple__61;
-static PyObject *__pyx_tuple__62;
static PyObject *__pyx_tuple__63;
-static PyObject *__pyx_tuple__65;
+static PyObject *__pyx_tuple__64;
static PyObject *__pyx_tuple__66;
-static PyObject *__pyx_tuple__68;
+static PyObject *__pyx_tuple__70;
+static PyObject *__pyx_tuple__71;
static PyObject *__pyx_tuple__72;
-static PyObject *__pyx_tuple__73;
static PyObject *__pyx_tuple__74;
static PyObject *__pyx_tuple__75;
-static PyObject *__pyx_tuple__76;
-static PyObject *__pyx_tuple__77;
static PyObject *__pyx_tuple__78;
static PyObject *__pyx_tuple__79;
static PyObject *__pyx_tuple__80;
static PyObject *__pyx_tuple__82;
-static PyObject *__pyx_tuple__83;
+static PyObject *__pyx_tuple__84;
+static PyObject *__pyx_tuple__85;
static PyObject *__pyx_tuple__86;
static PyObject *__pyx_tuple__87;
-static PyObject *__pyx_tuple__89;
+static PyObject *__pyx_tuple__90;
static PyObject *__pyx_tuple__91;
-static PyObject *__pyx_tuple__92;
-static PyObject *__pyx_tuple__93;
static PyObject *__pyx_tuple__94;
+static PyObject *__pyx_tuple__95;
+static PyObject *__pyx_tuple__96;
static PyObject *__pyx_tuple__97;
static PyObject *__pyx_tuple__98;
-static PyObject *__pyx_slice__100;
+static PyObject *__pyx_tuple__99;
+static PyObject *__pyx_slice__102;
+static PyObject *__pyx_slice__107;
+static PyObject *__pyx_slice__108;
static PyObject *__pyx_slice__109;
+static PyObject *__pyx_slice__110;
+static PyObject *__pyx_slice__113;
static PyObject *__pyx_slice__114;
static PyObject *__pyx_slice__115;
-static PyObject *__pyx_slice__116;
static PyObject *__pyx_slice__117;
-static PyObject *__pyx_slice__120;
-static PyObject *__pyx_slice__121;
-static PyObject *__pyx_slice__122;
-static PyObject *__pyx_slice__124;
+static PyObject *__pyx_slice__126;
+static PyObject *__pyx_tuple__100;
static PyObject *__pyx_tuple__101;
-static PyObject *__pyx_tuple__102;
static PyObject *__pyx_tuple__103;
static PyObject *__pyx_tuple__104;
static PyObject *__pyx_tuple__105;
static PyObject *__pyx_tuple__106;
-static PyObject *__pyx_tuple__107;
-static PyObject *__pyx_tuple__108;
-static PyObject *__pyx_tuple__110;
static PyObject *__pyx_tuple__111;
static PyObject *__pyx_tuple__112;
-static PyObject *__pyx_tuple__113;
+static PyObject *__pyx_tuple__116;
static PyObject *__pyx_tuple__118;
static PyObject *__pyx_tuple__119;
-static PyObject *__pyx_tuple__123;
+static PyObject *__pyx_tuple__120;
+static PyObject *__pyx_tuple__121;
+static PyObject *__pyx_tuple__122;
static PyObject *__pyx_tuple__125;
-static PyObject *__pyx_tuple__126;
static PyObject *__pyx_tuple__127;
static PyObject *__pyx_tuple__128;
static PyObject *__pyx_tuple__129;
+static PyObject *__pyx_tuple__130;
static PyObject *__pyx_tuple__132;
-static PyObject *__pyx_tuple__133;
static PyObject *__pyx_tuple__134;
static PyObject *__pyx_tuple__135;
static PyObject *__pyx_tuple__137;
static PyObject *__pyx_tuple__139;
-static PyObject *__pyx_tuple__140;
-static PyObject *__pyx_tuple__142;
-static PyObject *__pyx_tuple__144;
-static PyObject *__pyx_tuple__146;
-static PyObject *__pyx_tuple__148;
-static PyObject *__pyx_tuple__150;
-static PyObject *__pyx_tuple__152;
-static PyObject *__pyx_tuple__154;
-static PyObject *__pyx_tuple__156;
-static PyObject *__pyx_tuple__158;
-static PyObject *__pyx_tuple__160;
-static PyObject *__pyx_tuple__162;
-static PyObject *__pyx_tuple__164;
-static PyObject *__pyx_tuple__166;
-static PyObject *__pyx_tuple__168;
-static PyObject *__pyx_tuple__170;
-static PyObject *__pyx_tuple__172;
-static PyObject *__pyx_tuple__174;
-static PyObject *__pyx_tuple__176;
-static PyObject *__pyx_tuple__178;
-static PyObject *__pyx_tuple__180;
-static PyObject *__pyx_tuple__182;
-static PyObject *__pyx_tuple__184;
-static PyObject *__pyx_tuple__186;
-static PyObject *__pyx_tuple__188;
+static PyObject *__pyx_tuple__141;
+static PyObject *__pyx_tuple__143;
+static PyObject *__pyx_tuple__145;
+static PyObject *__pyx_tuple__147;
+static PyObject *__pyx_tuple__149;
+static PyObject *__pyx_tuple__151;
+static PyObject *__pyx_tuple__153;
+static PyObject *__pyx_tuple__155;
+static PyObject *__pyx_tuple__157;
+static PyObject *__pyx_tuple__159;
+static PyObject *__pyx_tuple__161;
+static PyObject *__pyx_tuple__163;
+static PyObject *__pyx_tuple__165;
+static PyObject *__pyx_tuple__167;
+static PyObject *__pyx_tuple__169;
+static PyObject *__pyx_tuple__171;
+static PyObject *__pyx_tuple__173;
+static PyObject *__pyx_tuple__175;
+static PyObject *__pyx_tuple__177;
+static PyObject *__pyx_tuple__179;
+static PyObject *__pyx_tuple__181;
+static PyObject *__pyx_tuple__183;
+static PyObject *__pyx_tuple__185;
+static PyObject *__pyx_tuple__187;
+static PyObject *__pyx_tuple__189;
static PyObject *__pyx_tuple__190;
-static PyObject *__pyx_tuple__192;
-static PyObject *__pyx_tuple__194;
-static PyObject *__pyx_tuple__195;
-static PyObject *__pyx_codeobj__130;
+static PyObject *__pyx_codeobj__123;
+static PyObject *__pyx_codeobj__124;
static PyObject *__pyx_codeobj__131;
+static PyObject *__pyx_codeobj__133;
static PyObject *__pyx_codeobj__136;
static PyObject *__pyx_codeobj__138;
-static PyObject *__pyx_codeobj__141;
-static PyObject *__pyx_codeobj__143;
-static PyObject *__pyx_codeobj__145;
-static PyObject *__pyx_codeobj__147;
-static PyObject *__pyx_codeobj__149;
-static PyObject *__pyx_codeobj__151;
-static PyObject *__pyx_codeobj__153;
-static PyObject *__pyx_codeobj__155;
-static PyObject *__pyx_codeobj__157;
-static PyObject *__pyx_codeobj__159;
-static PyObject *__pyx_codeobj__161;
-static PyObject *__pyx_codeobj__163;
-static PyObject *__pyx_codeobj__165;
-static PyObject *__pyx_codeobj__167;
-static PyObject *__pyx_codeobj__169;
-static PyObject *__pyx_codeobj__171;
-static PyObject *__pyx_codeobj__173;
-static PyObject *__pyx_codeobj__175;
-static PyObject *__pyx_codeobj__177;
-static PyObject *__pyx_codeobj__179;
-static PyObject *__pyx_codeobj__181;
-static PyObject *__pyx_codeobj__183;
-static PyObject *__pyx_codeobj__185;
-static PyObject *__pyx_codeobj__187;
-static PyObject *__pyx_codeobj__189;
+static PyObject *__pyx_codeobj__140;
+static PyObject *__pyx_codeobj__142;
+static PyObject *__pyx_codeobj__144;
+static PyObject *__pyx_codeobj__146;
+static PyObject *__pyx_codeobj__148;
+static PyObject *__pyx_codeobj__150;
+static PyObject *__pyx_codeobj__152;
+static PyObject *__pyx_codeobj__154;
+static PyObject *__pyx_codeobj__156;
+static PyObject *__pyx_codeobj__158;
+static PyObject *__pyx_codeobj__160;
+static PyObject *__pyx_codeobj__162;
+static PyObject *__pyx_codeobj__164;
+static PyObject *__pyx_codeobj__166;
+static PyObject *__pyx_codeobj__168;
+static PyObject *__pyx_codeobj__170;
+static PyObject *__pyx_codeobj__172;
+static PyObject *__pyx_codeobj__174;
+static PyObject *__pyx_codeobj__176;
+static PyObject *__pyx_codeobj__178;
+static PyObject *__pyx_codeobj__180;
+static PyObject *__pyx_codeobj__182;
+static PyObject *__pyx_codeobj__184;
+static PyObject *__pyx_codeobj__186;
+static PyObject *__pyx_codeobj__188;
static PyObject *__pyx_codeobj__191;
-static PyObject *__pyx_codeobj__193;
-static PyObject *__pyx_codeobj__196;
static PyObject *__pyx_gb_7netCDF4_8_netCDF4_24generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
-/* "netCDF4/_netCDF4.pyx":1018
+/* "netCDF4/_netCDF4.pyx":1031
* _format_dict['NETCDF3_64BIT'] = NC_FORMAT_64BIT
* # invert dictionary mapping
* _reverse_format_dict = dict((v, k) for k, v in _format_dict.iteritems()) # <<<<<<<<<<<<<<
@@ -3166,9 +3325,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_22genexpr(CYTHON_UNUSED PyObject *_
struct __pyx_obj_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("genexpr", 0);
__pyx_cur_scope = (struct __pyx_obj_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr *)__pyx_tp_new_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr(__pyx_ptype_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
@@ -3177,7 +3333,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_22genexpr(CYTHON_UNUSED PyObject *_
}
__Pyx_GOTREF(__pyx_cur_scope);
{
- __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_7netCDF4_8_netCDF4_24generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!gen)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_7netCDF4_8_netCDF4_24generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_genexpr); if (unlikely(!gen)) __PYX_ERR(0, 1031, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
@@ -3204,9 +3360,6 @@ static PyObject *__pyx_gb_7netCDF4_8_netCDF4_24generator(__pyx_CoroutineObject *
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
@@ -3216,17 +3369,17 @@ static PyObject *__pyx_gb_7netCDF4_8_netCDF4_24generator(__pyx_CoroutineObject *
return NULL;
}
__pyx_L3_first_run:;
- if (unlikely(!__pyx_sent_value)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_r = PyDict_New(); if (unlikely(!__pyx_r)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 1031, __pyx_L1_error)
+ __pyx_r = PyDict_New(); if (unlikely(!__pyx_r)) __PYX_ERR(0, 1031, __pyx_L1_error)
__Pyx_GOTREF(__pyx_r);
__pyx_t_2 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1031, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (unlikely(__pyx_t_5 == Py_None)) {
PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "iteritems");
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1031, __pyx_L1_error)
}
- __pyx_t_6 = __Pyx_dict_iterator(__pyx_t_5, 0, __pyx_n_s_iteritems, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_dict_iterator(__pyx_t_5, 0, __pyx_n_s_iteritems, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1031, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_1);
@@ -3235,7 +3388,7 @@ static PyObject *__pyx_gb_7netCDF4_8_netCDF4_24generator(__pyx_CoroutineObject *
while (1) {
__pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_6, &__pyx_t_5, NULL, __pyx_t_4);
if (unlikely(__pyx_t_7 == 0)) break;
- if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 1031, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_k);
@@ -3246,7 +3399,7 @@ static PyObject *__pyx_gb_7netCDF4_8_netCDF4_24generator(__pyx_CoroutineObject *
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_v, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
__pyx_t_5 = 0;
- if (unlikely(PyDict_SetItem(__pyx_r, (PyObject*)__pyx_cur_scope->__pyx_v_v, (PyObject*)__pyx_cur_scope->__pyx_v_k))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItem(__pyx_r, (PyObject*)__pyx_cur_scope->__pyx_v_v, (PyObject*)__pyx_cur_scope->__pyx_v_k))) __PYX_ERR(0, 1031, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -3266,7 +3419,7 @@ static PyObject *__pyx_gb_7netCDF4_8_netCDF4_24generator(__pyx_CoroutineObject *
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":954
+/* "netCDF4/_netCDF4.pyx":957
* # check for required version of netcdf-4 and hdf5.
*
* def _gethdf5libversion(): # <<<<<<<<<<<<<<
@@ -3301,12 +3454,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_gethdf5libversion", 0);
- /* "netCDF4/_netCDF4.pyx":955
+ /* "netCDF4/_netCDF4.pyx":958
*
* def _gethdf5libversion():
* majorvers = H5_VERS_MAJOR # <<<<<<<<<<<<<<
@@ -3315,7 +3465,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
*/
__pyx_v_majorvers = H5_VERS_MAJOR;
- /* "netCDF4/_netCDF4.pyx":956
+ /* "netCDF4/_netCDF4.pyx":959
* def _gethdf5libversion():
* majorvers = H5_VERS_MAJOR
* minorvers = H5_VERS_MINOR # <<<<<<<<<<<<<<
@@ -3324,7 +3474,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
*/
__pyx_v_minorvers = H5_VERS_MINOR;
- /* "netCDF4/_netCDF4.pyx":957
+ /* "netCDF4/_netCDF4.pyx":960
* majorvers = H5_VERS_MAJOR
* minorvers = H5_VERS_MINOR
* releasevers = H5_VERS_RELEASE # <<<<<<<<<<<<<<
@@ -3333,30 +3483,30 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
*/
__pyx_v_releasevers = H5_VERS_RELEASE;
- /* "netCDF4/_netCDF4.pyx":958
+ /* "netCDF4/_netCDF4.pyx":961
* minorvers = H5_VERS_MINOR
* releasevers = H5_VERS_RELEASE
* patchstring = H5_VERS_SUBRELEASE.decode('ascii') # <<<<<<<<<<<<<<
* if not patchstring:
* return '%d.%d.%d' % (majorvers,minorvers,releasevers)
*/
- __pyx_t_1 = __Pyx_decode_c_string(H5_VERS_SUBRELEASE, 0, strlen(H5_VERS_SUBRELEASE), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(H5_VERS_SUBRELEASE, 0, strlen(H5_VERS_SUBRELEASE), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_patchstring = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":959
+ /* "netCDF4/_netCDF4.pyx":962
* releasevers = H5_VERS_RELEASE
* patchstring = H5_VERS_SUBRELEASE.decode('ascii')
* if not patchstring: # <<<<<<<<<<<<<<
* return '%d.%d.%d' % (majorvers,minorvers,releasevers)
* else:
*/
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_patchstring); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_patchstring); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 962, __pyx_L1_error)
__pyx_t_3 = ((!__pyx_t_2) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":960
+ /* "netCDF4/_netCDF4.pyx":963
* patchstring = H5_VERS_SUBRELEASE.decode('ascii')
* if not patchstring:
* return '%d.%d.%d' % (majorvers,minorvers,releasevers) # <<<<<<<<<<<<<<
@@ -3364,13 +3514,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
* return '%d.%d.%d-%s' % (majorvers,minorvers,releasevers,patchstring)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_majorvers); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_majorvers); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_minorvers); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_minorvers); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_releasevers); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_releasevers); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
@@ -3381,14 +3531,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
__pyx_t_1 = 0;
__pyx_t_4 = 0;
__pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_d_d_d, __pyx_t_6); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_d_d_d, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":959
+ /* "netCDF4/_netCDF4.pyx":962
* releasevers = H5_VERS_RELEASE
* patchstring = H5_VERS_SUBRELEASE.decode('ascii')
* if not patchstring: # <<<<<<<<<<<<<<
@@ -3397,7 +3547,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
*/
}
- /* "netCDF4/_netCDF4.pyx":962
+ /* "netCDF4/_netCDF4.pyx":965
* return '%d.%d.%d' % (majorvers,minorvers,releasevers)
* else:
* return '%d.%d.%d-%s' % (majorvers,minorvers,releasevers,patchstring) # <<<<<<<<<<<<<<
@@ -3406,13 +3556,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_majorvers); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 962; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_majorvers); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_minorvers); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 962; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_minorvers); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_releasevers); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 962; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_releasevers); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 962; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5);
@@ -3426,7 +3576,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
__pyx_t_5 = 0;
__pyx_t_6 = 0;
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_d_d_d_s, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 962; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_d_d_d_s, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_4;
@@ -3434,7 +3584,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":954
+ /* "netCDF4/_netCDF4.pyx":957
* # check for required version of netcdf-4 and hdf5.
*
* def _gethdf5libversion(): # <<<<<<<<<<<<<<
@@ -3457,7 +3607,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4__gethdf5libversion(CYTHON_UNUSED Py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":964
+/* "netCDF4/_netCDF4.pyx":967
* return '%d.%d.%d-%s' % (majorvers,minorvers,releasevers,patchstring)
*
* def getlibversion(): # <<<<<<<<<<<<<<
@@ -3485,12 +3635,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_2getlibversion(CYTHON_UNUSED PyObje
__Pyx_RefNannyDeclarations
char *__pyx_t_1;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("getlibversion", 0);
- /* "netCDF4/_netCDF4.pyx":971
+ /* "netCDF4/_netCDF4.pyx":974
* used to build the module, and when it was built.
* """
* return (<char *>nc_inq_libvers()).decode('ascii') # <<<<<<<<<<<<<<
@@ -3499,14 +3646,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_2getlibversion(CYTHON_UNUSED PyObje
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = ((char *)nc_inq_libvers());
- __pyx_t_2 = __Pyx_decode_c_string(__pyx_t_1, 0, strlen(__pyx_t_1), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_decode_c_string(__pyx_t_1, 0, strlen(__pyx_t_1), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 974, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":964
+ /* "netCDF4/_netCDF4.pyx":967
* return '%d.%d.%d-%s' % (majorvers,minorvers,releasevers,patchstring)
*
* def getlibversion(): # <<<<<<<<<<<<<<
@@ -3525,7 +3672,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_2getlibversion(CYTHON_UNUSED PyObje
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1064
+/* "netCDF4/_netCDF4.pyx":1077
* # internal C functions.
*
* cdef _get_att_names(int grpid, int varid): # <<<<<<<<<<<<<<
@@ -3552,12 +3699,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
int __pyx_t_11;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_att_names", 0);
- /* "netCDF4/_netCDF4.pyx":1068
+ /* "netCDF4/_netCDF4.pyx":1081
* cdef int ierr, numatts, n
* cdef char namstring[NC_MAX_NAME+1]
* if varid == NC_GLOBAL: # <<<<<<<<<<<<<<
@@ -3567,7 +3711,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
__pyx_t_1 = ((__pyx_v_varid == NC_GLOBAL) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1069
+ /* "netCDF4/_netCDF4.pyx":1082
* cdef char namstring[NC_MAX_NAME+1]
* if varid == NC_GLOBAL:
* with nogil: # <<<<<<<<<<<<<<
@@ -3581,7 +3725,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1070
+ /* "netCDF4/_netCDF4.pyx":1083
* if varid == NC_GLOBAL:
* with nogil:
* ierr = nc_inq_natts(grpid, &numatts) # <<<<<<<<<<<<<<
@@ -3591,7 +3735,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
__pyx_v_ierr = nc_inq_natts(__pyx_v_grpid, (&__pyx_v_numatts));
}
- /* "netCDF4/_netCDF4.pyx":1069
+ /* "netCDF4/_netCDF4.pyx":1082
* cdef char namstring[NC_MAX_NAME+1]
* if varid == NC_GLOBAL:
* with nogil: # <<<<<<<<<<<<<<
@@ -3609,7 +3753,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
}
}
- /* "netCDF4/_netCDF4.pyx":1068
+ /* "netCDF4/_netCDF4.pyx":1081
* cdef int ierr, numatts, n
* cdef char namstring[NC_MAX_NAME+1]
* if varid == NC_GLOBAL: # <<<<<<<<<<<<<<
@@ -3619,7 +3763,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":1072
+ /* "netCDF4/_netCDF4.pyx":1085
* ierr = nc_inq_natts(grpid, &numatts)
* else:
* with nogil: # <<<<<<<<<<<<<<
@@ -3634,17 +3778,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1073
+ /* "netCDF4/_netCDF4.pyx":1086
* else:
* with nogil:
* ierr = nc_inq_varnatts(grpid, varid, &numatts) # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
__pyx_v_ierr = nc_inq_varnatts(__pyx_v_grpid, __pyx_v_varid, (&__pyx_v_numatts));
}
- /* "netCDF4/_netCDF4.pyx":1072
+ /* "netCDF4/_netCDF4.pyx":1085
* ierr = nc_inq_natts(grpid, &numatts)
* else:
* with nogil: # <<<<<<<<<<<<<<
@@ -3664,62 +3808,62 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":1074
+ /* "netCDF4/_netCDF4.pyx":1087
* with nogil:
* ierr = nc_inq_varnatts(grpid, varid, &numatts)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* attslist = []
*/
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1075
+ /* "netCDF4/_netCDF4.pyx":1088
* ierr = nc_inq_varnatts(grpid, varid, &numatts)
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
* attslist = []
* for n from 0 <= n < numatts:
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1075; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1088, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1075; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1088, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1075; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1088, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1075; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1088, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1074
+ /* "netCDF4/_netCDF4.pyx":1087
* with nogil:
* ierr = nc_inq_varnatts(grpid, varid, &numatts)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* attslist = []
*/
}
- /* "netCDF4/_netCDF4.pyx":1076
+ /* "netCDF4/_netCDF4.pyx":1089
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* attslist = [] # <<<<<<<<<<<<<<
* for n from 0 <= n < numatts:
* with nogil:
*/
- __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1076; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1089, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_attslist = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":1077
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ /* "netCDF4/_netCDF4.pyx":1090
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* attslist = []
* for n from 0 <= n < numatts: # <<<<<<<<<<<<<<
* with nogil:
@@ -3728,7 +3872,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
__pyx_t_5 = __pyx_v_numatts;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_5; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":1078
+ /* "netCDF4/_netCDF4.pyx":1091
* attslist = []
* for n from 0 <= n < numatts:
* with nogil: # <<<<<<<<<<<<<<
@@ -3742,17 +3886,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1079
+ /* "netCDF4/_netCDF4.pyx":1092
* for n from 0 <= n < numatts:
* with nogil:
* ierr = nc_inq_attname(grpid, varid, n, namstring) # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
__pyx_v_ierr = nc_inq_attname(__pyx_v_grpid, __pyx_v_varid, __pyx_v_n, __pyx_v_namstring);
}
- /* "netCDF4/_netCDF4.pyx":1078
+ /* "netCDF4/_netCDF4.pyx":1091
* attslist = []
* for n from 0 <= n < numatts:
* with nogil: # <<<<<<<<<<<<<<
@@ -3770,63 +3914,63 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
}
}
- /* "netCDF4/_netCDF4.pyx":1080
+ /* "netCDF4/_netCDF4.pyx":1093
* with nogil:
* ierr = nc_inq_attname(grpid, varid, n, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* attslist.append(namstring.decode(default_encoding,unicode_error))
*/
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1081
+ /* "netCDF4/_netCDF4.pyx":1094
* ierr = nc_inq_attname(grpid, varid, n, namstring)
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
* attslist.append(namstring.decode(default_encoding,unicode_error))
* return attslist
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1081; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1094, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1081; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1094, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1081; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1094, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1081; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1094, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1080
+ /* "netCDF4/_netCDF4.pyx":1093
* with nogil:
* ierr = nc_inq_attname(grpid, varid, n, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* attslist.append(namstring.decode(default_encoding,unicode_error))
*/
}
- /* "netCDF4/_netCDF4.pyx":1082
+ /* "netCDF4/_netCDF4.pyx":1095
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* attslist.append(namstring.decode(default_encoding,unicode_error)) # <<<<<<<<<<<<<<
* return attslist
*
*/
- __pyx_t_4 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1082; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1082; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1082; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1082; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -3840,7 +3984,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1082; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -3851,16 +3995,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_4 = 0;
__pyx_t_7 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1082; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_attslist, __pyx_t_3); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1082; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_attslist, __pyx_t_3); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 1095, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":1083
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ /* "netCDF4/_netCDF4.pyx":1096
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* attslist.append(namstring.decode(default_encoding,unicode_error))
* return attslist # <<<<<<<<<<<<<<
*
@@ -3871,7 +4015,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
__pyx_r = __pyx_v_attslist;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1064
+ /* "netCDF4/_netCDF4.pyx":1077
* # internal C functions.
*
* cdef _get_att_names(int grpid, int varid): # <<<<<<<<<<<<<<
@@ -3896,7 +4040,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att_names(int __pyx_v_grpid, in
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1085
+/* "netCDF4/_netCDF4.pyx":1098
* return attslist
*
* cdef _get_att(grp, int varid, name): # <<<<<<<<<<<<<<
@@ -3943,47 +4087,44 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
PyObject *__pyx_t_24 = NULL;
PyObject *__pyx_t_25 = NULL;
PyObject *__pyx_t_26 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_att", 0);
- /* "netCDF4/_netCDF4.pyx":1093
+ /* "netCDF4/_netCDF4.pyx":1106
* cdef nc_type att_type
* cdef ndarray value_arr
* bytestr = _strencode(name) # <<<<<<<<<<<<<<
* attname = bytestr
* _grpid = grp._grpid
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1093; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1106, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1094
+ /* "netCDF4/_netCDF4.pyx":1107
* cdef ndarray value_arr
* bytestr = _strencode(name)
* attname = bytestr # <<<<<<<<<<<<<<
* _grpid = grp._grpid
* with nogil:
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1094; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 1107, __pyx_L1_error)
__pyx_v_attname = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":1095
+ /* "netCDF4/_netCDF4.pyx":1108
* bytestr = _strencode(name)
* attname = bytestr
* _grpid = grp._grpid # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_att(_grpid, varid, attname, &att_type, &att_len)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1108, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1108, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_3;
- /* "netCDF4/_netCDF4.pyx":1096
+ /* "netCDF4/_netCDF4.pyx":1109
* attname = bytestr
* _grpid = grp._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -3997,7 +4138,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1097
+ /* "netCDF4/_netCDF4.pyx":1110
* _grpid = grp._grpid
* with nogil:
* ierr = nc_inq_att(_grpid, varid, attname, &att_type, &att_len) # <<<<<<<<<<<<<<
@@ -4007,7 +4148,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_v_ierr = nc_inq_att(__pyx_v__grpid, __pyx_v_varid, __pyx_v_attname, (&__pyx_v_att_type), (&__pyx_v_att_len));
}
- /* "netCDF4/_netCDF4.pyx":1096
+ /* "netCDF4/_netCDF4.pyx":1109
* attname = bytestr
* _grpid = grp._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -4025,7 +4166,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
}
}
- /* "netCDF4/_netCDF4.pyx":1098
+ /* "netCDF4/_netCDF4.pyx":1111
* with nogil:
* ierr = nc_inq_att(_grpid, varid, attname, &att_type, &att_len)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -4035,7 +4176,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_4 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":1099
+ /* "netCDF4/_netCDF4.pyx":1112
* ierr = nc_inq_att(_grpid, varid, attname, &att_type, &att_len)
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -4043,22 +4184,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* if att_type == NC_CHAR:
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1099; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1112, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1099; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1112, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1099; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1112, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1099; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1112, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1098
+ /* "netCDF4/_netCDF4.pyx":1111
* with nogil:
* ierr = nc_inq_att(_grpid, varid, attname, &att_type, &att_len)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -4067,7 +4208,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1101
+ /* "netCDF4/_netCDF4.pyx":1114
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # attribute is a character or string ...
* if att_type == NC_CHAR: # <<<<<<<<<<<<<<
@@ -4077,19 +4218,19 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
switch (__pyx_v_att_type) {
case NC_CHAR:
- /* "netCDF4/_netCDF4.pyx":1102
+ /* "netCDF4/_netCDF4.pyx":1115
* # attribute is a character or string ...
* if att_type == NC_CHAR:
* value_arr = numpy.empty(att_len,'S1') # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_get_att_text(_grpid, varid, attname, <char *>value_arr.data)
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyInt_FromSize_t(__pyx_v_att_len); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyInt_FromSize_t(__pyx_v_att_len); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_7 = NULL;
__pyx_t_8 = 0;
@@ -4103,7 +4244,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_8 = 1;
}
}
- __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -4114,15 +4255,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__Pyx_GIVEREF(__pyx_n_s_S1);
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_n_s_S1);
__pyx_t_5 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 1115, __pyx_L1_error)
__pyx_v_value_arr = ((PyArrayObject *)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1103
+ /* "netCDF4/_netCDF4.pyx":1116
* if att_type == NC_CHAR:
* value_arr = numpy.empty(att_len,'S1')
* with nogil: # <<<<<<<<<<<<<<
@@ -4136,7 +4277,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1104
+ /* "netCDF4/_netCDF4.pyx":1117
* value_arr = numpy.empty(att_len,'S1')
* with nogil:
* ierr = nc_get_att_text(_grpid, varid, attname, <char *>value_arr.data) # <<<<<<<<<<<<<<
@@ -4146,7 +4287,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_v_ierr = nc_get_att_text(__pyx_v__grpid, __pyx_v_varid, __pyx_v_attname, ((char *)__pyx_v_value_arr->data));
}
- /* "netCDF4/_netCDF4.pyx":1103
+ /* "netCDF4/_netCDF4.pyx":1116
* if att_type == NC_CHAR:
* value_arr = numpy.empty(att_len,'S1')
* with nogil: # <<<<<<<<<<<<<<
@@ -4164,7 +4305,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
}
}
- /* "netCDF4/_netCDF4.pyx":1105
+ /* "netCDF4/_netCDF4.pyx":1118
* with nogil:
* ierr = nc_get_att_text(_grpid, varid, attname, <char *>value_arr.data)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -4174,7 +4315,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_4 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":1106
+ /* "netCDF4/_netCDF4.pyx":1119
* ierr = nc_get_att_text(_grpid, varid, attname, <char *>value_arr.data)
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -4182,22 +4323,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* # make sure _FillValue for character arrays is a byte on python 3
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1119, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1119, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1119, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1119, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1105
+ /* "netCDF4/_netCDF4.pyx":1118
* with nogil:
* ierr = nc_get_att_text(_grpid, varid, attname, <char *>value_arr.data)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -4206,46 +4347,46 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1107
+ /* "netCDF4/_netCDF4.pyx":1120
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if name == '_FillValue' and python3: # <<<<<<<<<<<<<<
* # make sure _FillValue for character arrays is a byte on python 3
* # (issue 271).
*/
- __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_FillValue, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_FillValue, Py_EQ)); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 1120, __pyx_L1_error)
if (__pyx_t_10) {
} else {
__pyx_t_4 = __pyx_t_10;
goto __pyx_L12_bool_binop_done;
}
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1120, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 1120, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_4 = __pyx_t_10;
__pyx_L12_bool_binop_done:;
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":1110
+ /* "netCDF4/_netCDF4.pyx":1123
* # make sure _FillValue for character arrays is a byte on python 3
* # (issue 271).
* pstring = bytes(value_arr) # <<<<<<<<<<<<<<
* else:
* pstring =\
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1123, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)__pyx_v_value_arr));
__Pyx_GIVEREF(((PyObject *)__pyx_v_value_arr));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_value_arr));
- __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&PyBytes_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1110; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&PyBytes_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1123, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_pstring = __pyx_t_6;
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1107
+ /* "netCDF4/_netCDF4.pyx":1120
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if name == '_FillValue' and python3: # <<<<<<<<<<<<<<
@@ -4255,7 +4396,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
goto __pyx_L11;
}
- /* "netCDF4/_netCDF4.pyx":1113
+ /* "netCDF4/_netCDF4.pyx":1126
* else:
* pstring =\
* value_arr.tostring().decode(default_encoding,unicode_error).replace('\x00','') # <<<<<<<<<<<<<<
@@ -4263,7 +4404,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* elif att_type == NC_STRING:
*/
/*else*/ {
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_tostring); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_tostring); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_9))) {
@@ -4276,19 +4417,19 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1126, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_decode); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_decode); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_7 = NULL;
__pyx_t_8 = 0;
@@ -4302,7 +4443,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_8 = 1;
}
}
- __pyx_t_11 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -4313,14 +4454,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_8, __pyx_t_5);
__pyx_t_1 = 0;
__pyx_t_5 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_replace); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_replace); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_v_pstring = __pyx_t_6;
@@ -4328,7 +4469,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
}
__pyx_L11:;
- /* "netCDF4/_netCDF4.pyx":1114
+ /* "netCDF4/_netCDF4.pyx":1127
* pstring =\
* value_arr.tostring().decode(default_encoding,unicode_error).replace('\x00','')
* return pstring # <<<<<<<<<<<<<<
@@ -4340,7 +4481,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_r = __pyx_v_pstring;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1101
+ /* "netCDF4/_netCDF4.pyx":1114
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # attribute is a character or string ...
* if att_type == NC_CHAR: # <<<<<<<<<<<<<<
@@ -4349,7 +4490,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
break;
- /* "netCDF4/_netCDF4.pyx":1115
+ /* "netCDF4/_netCDF4.pyx":1128
* value_arr.tostring().decode(default_encoding,unicode_error).replace('\x00','')
* return pstring
* elif att_type == NC_STRING: # <<<<<<<<<<<<<<
@@ -4358,7 +4499,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
case NC_STRING:
- /* "netCDF4/_netCDF4.pyx":1116
+ /* "netCDF4/_netCDF4.pyx":1129
* return pstring
* elif att_type == NC_STRING:
* if att_len == 1: # <<<<<<<<<<<<<<
@@ -4368,7 +4509,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_4 = ((__pyx_v_att_len == 1) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":1117
+ /* "netCDF4/_netCDF4.pyx":1130
* elif att_type == NC_STRING:
* if att_len == 1:
* with nogil: # <<<<<<<<<<<<<<
@@ -4382,7 +4523,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1118
+ /* "netCDF4/_netCDF4.pyx":1131
* if att_len == 1:
* with nogil:
* ierr = nc_get_att_string(_grpid, varid, attname, &stratt) # <<<<<<<<<<<<<<
@@ -4392,7 +4533,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_v_ierr = nc_get_att_string(__pyx_v__grpid, __pyx_v_varid, __pyx_v_attname, (&__pyx_v_stratt));
}
- /* "netCDF4/_netCDF4.pyx":1117
+ /* "netCDF4/_netCDF4.pyx":1130
* elif att_type == NC_STRING:
* if att_len == 1:
* with nogil: # <<<<<<<<<<<<<<
@@ -4410,21 +4551,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
}
}
- /* "netCDF4/_netCDF4.pyx":1119
+ /* "netCDF4/_netCDF4.pyx":1132
* with nogil:
* ierr = nc_get_att_string(_grpid, varid, attname, &stratt)
* pstring = stratt.decode(default_encoding,unicode_error).replace('\x00','') # <<<<<<<<<<<<<<
* ierr = nc_free_string(1, &stratt) # free memory in netcdf C lib
* return pstring
*/
- __pyx_t_9 = __Pyx_PyBytes_FromString(__pyx_v_stratt); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyBytes_FromString(__pyx_v_stratt); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_decode); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_decode); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_1 = NULL;
__pyx_t_8 = 0;
@@ -4438,7 +4579,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_8 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_1) {
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
@@ -4449,20 +4590,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_8, __pyx_t_5);
__pyx_t_9 = 0;
__pyx_t_5 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_replace); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_replace); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_v_pstring = __pyx_t_6;
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1120
+ /* "netCDF4/_netCDF4.pyx":1133
* ierr = nc_get_att_string(_grpid, varid, attname, &stratt)
* pstring = stratt.decode(default_encoding,unicode_error).replace('\x00','')
* ierr = nc_free_string(1, &stratt) # free memory in netcdf C lib # <<<<<<<<<<<<<<
@@ -4471,7 +4612,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
__pyx_v_ierr = nc_free_string(1, (&__pyx_v_stratt));
- /* "netCDF4/_netCDF4.pyx":1121
+ /* "netCDF4/_netCDF4.pyx":1134
* pstring = stratt.decode(default_encoding,unicode_error).replace('\x00','')
* ierr = nc_free_string(1, &stratt) # free memory in netcdf C lib
* return pstring # <<<<<<<<<<<<<<
@@ -4483,7 +4624,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_r = __pyx_v_pstring;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1116
+ /* "netCDF4/_netCDF4.pyx":1129
* return pstring
* elif att_type == NC_STRING:
* if att_len == 1: # <<<<<<<<<<<<<<
@@ -4492,7 +4633,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1123
+ /* "netCDF4/_netCDF4.pyx":1136
* return pstring
* else:
* raise KeyError('vlen string array attributes not supported') # <<<<<<<<<<<<<<
@@ -4500,14 +4641,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* # a regular numeric or compound type.
*/
/*else*/ {
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1123; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1136, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1123; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1136, __pyx_L1_error)
}
- /* "netCDF4/_netCDF4.pyx":1115
+ /* "netCDF4/_netCDF4.pyx":1128
* value_arr.tostring().decode(default_encoding,unicode_error).replace('\x00','')
* return pstring
* elif att_type == NC_STRING: # <<<<<<<<<<<<<<
@@ -4517,7 +4658,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
break;
default:
- /* "netCDF4/_netCDF4.pyx":1126
+ /* "netCDF4/_netCDF4.pyx":1139
* else:
* # a regular numeric or compound type.
* if att_type == NC_LONG: # <<<<<<<<<<<<<<
@@ -4527,7 +4668,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_4 = ((__pyx_v_att_type == NC_LONG) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":1127
+ /* "netCDF4/_netCDF4.pyx":1140
* # a regular numeric or compound type.
* if att_type == NC_LONG:
* att_type = NC_INT # <<<<<<<<<<<<<<
@@ -4536,7 +4677,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
__pyx_v_att_type = NC_INT;
- /* "netCDF4/_netCDF4.pyx":1126
+ /* "netCDF4/_netCDF4.pyx":1139
* else:
* # a regular numeric or compound type.
* if att_type == NC_LONG: # <<<<<<<<<<<<<<
@@ -4545,7 +4686,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1128
+ /* "netCDF4/_netCDF4.pyx":1141
* if att_type == NC_LONG:
* att_type = NC_INT
* try: # <<<<<<<<<<<<<<
@@ -4553,40 +4694,42 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* value_arr = numpy.empty(att_len,type_att)
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_14);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1129
+ /* "netCDF4/_netCDF4.pyx":1142
* att_type = NC_INT
* try:
* type_att = _nctonptype[att_type] # see if it is a primitive type # <<<<<<<<<<<<<<
* value_arr = numpy.empty(att_len,type_att)
* except KeyError:
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1129; __pyx_clineno = __LINE__; goto __pyx_L19_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1142, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_6, __pyx_v_att_type, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1129; __pyx_clineno = __LINE__; goto __pyx_L19_error;};
+ __pyx_t_11 = __Pyx_GetItemInt(__pyx_t_6, __pyx_v_att_type, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1142, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_type_att = __pyx_t_11;
__pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1130
+ /* "netCDF4/_netCDF4.pyx":1143
* try:
* type_att = _nctonptype[att_type] # see if it is a primitive type
* value_arr = numpy.empty(att_len,type_att) # <<<<<<<<<<<<<<
* except KeyError:
* # check if it's a compound
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1130; __pyx_clineno = __LINE__; goto __pyx_L19_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1143, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1130; __pyx_clineno = __LINE__; goto __pyx_L19_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1143, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyInt_FromSize_t(__pyx_v_att_len); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1130; __pyx_clineno = __LINE__; goto __pyx_L19_error;}
+ __pyx_t_6 = __Pyx_PyInt_FromSize_t(__pyx_v_att_len); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1143, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_5 = NULL;
__pyx_t_8 = 0;
@@ -4600,7 +4743,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_8 = 1;
}
}
- __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1130; __pyx_clineno = __LINE__; goto __pyx_L19_error;}
+ __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1143, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5); __pyx_t_5 = NULL;
@@ -4611,15 +4754,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__Pyx_GIVEREF(__pyx_v_type_att);
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_type_att);
__pyx_t_6 = 0;
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1130; __pyx_clineno = __LINE__; goto __pyx_L19_error;}
+ __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1143, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- if (!(likely(((__pyx_t_11) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_11, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1130; __pyx_clineno = __LINE__; goto __pyx_L19_error;}
+ if (!(likely(((__pyx_t_11) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_11, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 1143, __pyx_L19_error)
__pyx_v_value_arr = ((PyArrayObject *)__pyx_t_11);
__pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1128
+ /* "netCDF4/_netCDF4.pyx":1141
* if att_type == NC_LONG:
* att_type = NC_INT
* try: # <<<<<<<<<<<<<<
@@ -4632,6 +4775,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
goto __pyx_L26_try_end;
__pyx_L19_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -4639,22 +4783,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1131
+ /* "netCDF4/_netCDF4.pyx":1144
* type_att = _nctonptype[att_type] # see if it is a primitive type
* value_arr = numpy.empty(att_len,type_att)
* except KeyError: # <<<<<<<<<<<<<<
* # check if it's a compound
* try:
*/
- __pyx_t_3 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_3 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_3) {
__Pyx_AddTraceback("netCDF4._netCDF4._get_att", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_7, &__pyx_t_9) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1131; __pyx_clineno = __LINE__; goto __pyx_L21_except_error;}
+ if (__Pyx_GetException(&__pyx_t_11, &__pyx_t_7, &__pyx_t_9) < 0) __PYX_ERR(0, 1144, __pyx_L21_except_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_9);
- /* "netCDF4/_netCDF4.pyx":1133
+ /* "netCDF4/_netCDF4.pyx":1146
* except KeyError:
* # check if it's a compound
* try: # <<<<<<<<<<<<<<
@@ -4662,37 +4806,39 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* value_arr = numpy.empty(att_len,type_att)
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1134
+ /* "netCDF4/_netCDF4.pyx":1147
* # check if it's a compound
* try:
* type_att = _read_compound(grp, att_type) # <<<<<<<<<<<<<<
* value_arr = numpy.empty(att_len,type_att)
* except:
*/
- __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__read_compound(__pyx_v_grp, __pyx_v_att_type, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1134; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__read_compound(__pyx_v_grp, __pyx_v_att_type, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1147, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_XDECREF_SET(__pyx_v_type_att, __pyx_t_6);
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1135
+ /* "netCDF4/_netCDF4.pyx":1148
* try:
* type_att = _read_compound(grp, att_type)
* value_arr = numpy.empty(att_len,type_att) # <<<<<<<<<<<<<<
* except:
* # check if it's an enum
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1135; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1148, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1135; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_empty); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1148, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyInt_FromSize_t(__pyx_v_att_len); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1135; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_5 = __Pyx_PyInt_FromSize_t(__pyx_v_att_len); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1148, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_18 = NULL;
__pyx_t_8 = 0;
@@ -4706,7 +4852,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_8 = 1;
}
}
- __pyx_t_19 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_19)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1135; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_19 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 1148, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_19);
if (__pyx_t_18) {
__Pyx_GIVEREF(__pyx_t_18); PyTuple_SET_ITEM(__pyx_t_19, 0, __pyx_t_18); __pyx_t_18 = NULL;
@@ -4717,15 +4863,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__Pyx_GIVEREF(__pyx_v_type_att);
PyTuple_SET_ITEM(__pyx_t_19, 1+__pyx_t_8, __pyx_v_type_att);
__pyx_t_5 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_19, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1135; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_19, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1148, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1135; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 1148, __pyx_L29_error)
__Pyx_XDECREF_SET(__pyx_v_value_arr, ((PyArrayObject *)__pyx_t_6));
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1133
+ /* "netCDF4/_netCDF4.pyx":1146
* except KeyError:
* # check if it's a compound
* try: # <<<<<<<<<<<<<<
@@ -4738,13 +4884,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
goto __pyx_L36_try_end;
__pyx_L29_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1136
+ /* "netCDF4/_netCDF4.pyx":1149
* type_att = _read_compound(grp, att_type)
* value_arr = numpy.empty(att_len,type_att)
* except: # <<<<<<<<<<<<<<
@@ -4753,12 +4900,12 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
/*except:*/ {
__Pyx_AddTraceback("netCDF4._netCDF4._get_att", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_1, &__pyx_t_19) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1136; __pyx_clineno = __LINE__; goto __pyx_L31_except_error;}
+ if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_1, &__pyx_t_19) < 0) __PYX_ERR(0, 1149, __pyx_L31_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_19);
- /* "netCDF4/_netCDF4.pyx":1138
+ /* "netCDF4/_netCDF4.pyx":1151
* except:
* # check if it's an enum
* try: # <<<<<<<<<<<<<<
@@ -4766,39 +4913,41 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* value_arr = numpy.empty(att_len,type_att.dtype)
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_22);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1139
+ /* "netCDF4/_netCDF4.pyx":1152
* # check if it's an enum
* try:
* type_att = _read_enum(grp, att_type) # <<<<<<<<<<<<<<
* value_arr = numpy.empty(att_len,type_att.dtype)
* except:
*/
- __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__read_enum(__pyx_v_grp, __pyx_v_att_type, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1139; __pyx_clineno = __LINE__; goto __pyx_L39_error;}
+ __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__read_enum(__pyx_v_grp, __pyx_v_att_type, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1152, __pyx_L39_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XDECREF_SET(__pyx_v_type_att, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":1140
+ /* "netCDF4/_netCDF4.pyx":1153
* try:
* type_att = _read_enum(grp, att_type)
* value_arr = numpy.empty(att_len,type_att.dtype) # <<<<<<<<<<<<<<
* except:
* raise KeyError('attribute %s has unsupported datatype' % attname)
*/
- __pyx_t_18 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1140; __pyx_clineno = __LINE__; goto __pyx_L39_error;}
+ __pyx_t_18 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1153, __pyx_L39_error)
__Pyx_GOTREF(__pyx_t_18);
- __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_empty); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1140; __pyx_clineno = __LINE__; goto __pyx_L39_error;}
+ __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_empty); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1153, __pyx_L39_error)
__Pyx_GOTREF(__pyx_t_23);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
- __pyx_t_18 = __Pyx_PyInt_FromSize_t(__pyx_v_att_len); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1140; __pyx_clineno = __LINE__; goto __pyx_L39_error;}
+ __pyx_t_18 = __Pyx_PyInt_FromSize_t(__pyx_v_att_len); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1153, __pyx_L39_error)
__Pyx_GOTREF(__pyx_t_18);
- __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_v_type_att, __pyx_n_s_dtype); if (unlikely(!__pyx_t_24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1140; __pyx_clineno = __LINE__; goto __pyx_L39_error;}
+ __pyx_t_24 = __Pyx_PyObject_GetAttrStr(__pyx_v_type_att, __pyx_n_s_dtype); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 1153, __pyx_L39_error)
__Pyx_GOTREF(__pyx_t_24);
__pyx_t_25 = NULL;
__pyx_t_8 = 0;
@@ -4812,7 +4961,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_8 = 1;
}
}
- __pyx_t_26 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1140; __pyx_clineno = __LINE__; goto __pyx_L39_error;}
+ __pyx_t_26 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 1153, __pyx_L39_error)
__Pyx_GOTREF(__pyx_t_26);
if (__pyx_t_25) {
__Pyx_GIVEREF(__pyx_t_25); PyTuple_SET_ITEM(__pyx_t_26, 0, __pyx_t_25); __pyx_t_25 = NULL;
@@ -4823,15 +4972,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
PyTuple_SET_ITEM(__pyx_t_26, 1+__pyx_t_8, __pyx_t_24);
__pyx_t_18 = 0;
__pyx_t_24 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_23, __pyx_t_26, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1140; __pyx_clineno = __LINE__; goto __pyx_L39_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_23, __pyx_t_26, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1153, __pyx_L39_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;
__Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
- if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1140; __pyx_clineno = __LINE__; goto __pyx_L39_error;}
+ if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 1153, __pyx_L39_error)
__Pyx_XDECREF_SET(__pyx_v_value_arr, ((PyArrayObject *)__pyx_t_5));
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":1138
+ /* "netCDF4/_netCDF4.pyx":1151
* except:
* # check if it's an enum
* try: # <<<<<<<<<<<<<<
@@ -4844,6 +4993,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
goto __pyx_L46_try_end;
__pyx_L39_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_25); __pyx_t_25 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_XDECREF(__pyx_t_24); __pyx_t_24 = 0;
@@ -4851,7 +5001,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":1141
+ /* "netCDF4/_netCDF4.pyx":1154
* type_att = _read_enum(grp, att_type)
* value_arr = numpy.empty(att_len,type_att.dtype)
* except: # <<<<<<<<<<<<<<
@@ -4860,44 +5010,45 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
/*except:*/ {
__Pyx_AddTraceback("netCDF4._netCDF4._get_att", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_23, &__pyx_t_26) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1141; __pyx_clineno = __LINE__; goto __pyx_L41_except_error;}
+ if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_23, &__pyx_t_26) < 0) __PYX_ERR(0, 1154, __pyx_L41_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_23);
__Pyx_GOTREF(__pyx_t_26);
- /* "netCDF4/_netCDF4.pyx":1142
+ /* "netCDF4/_netCDF4.pyx":1155
* value_arr = numpy.empty(att_len,type_att.dtype)
* except:
* raise KeyError('attribute %s has unsupported datatype' % attname) # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_get_att(_grpid, varid, attname, value_arr.data)
*/
- __pyx_t_24 = __Pyx_PyBytes_FromString(__pyx_v_attname); if (unlikely(!__pyx_t_24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1142; __pyx_clineno = __LINE__; goto __pyx_L41_except_error;}
+ __pyx_t_24 = __Pyx_PyBytes_FromString(__pyx_v_attname); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 1155, __pyx_L41_except_error)
__Pyx_GOTREF(__pyx_t_24);
- __pyx_t_18 = __Pyx_PyString_Format(__pyx_kp_s_attribute_s_has_unsupported_data, __pyx_t_24); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1142; __pyx_clineno = __LINE__; goto __pyx_L41_except_error;}
+ __pyx_t_18 = __Pyx_PyString_Format(__pyx_kp_s_attribute_s_has_unsupported_data, __pyx_t_24); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1155, __pyx_L41_except_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
- __pyx_t_24 = PyTuple_New(1); if (unlikely(!__pyx_t_24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1142; __pyx_clineno = __LINE__; goto __pyx_L41_except_error;}
+ __pyx_t_24 = PyTuple_New(1); if (unlikely(!__pyx_t_24)) __PYX_ERR(0, 1155, __pyx_L41_except_error)
__Pyx_GOTREF(__pyx_t_24);
__Pyx_GIVEREF(__pyx_t_18);
PyTuple_SET_ITEM(__pyx_t_24, 0, __pyx_t_18);
__pyx_t_18 = 0;
- __pyx_t_18 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_24, NULL); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1142; __pyx_clineno = __LINE__; goto __pyx_L41_except_error;}
+ __pyx_t_18 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_24, NULL); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1155, __pyx_L41_except_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_24); __pyx_t_24 = 0;
__Pyx_Raise(__pyx_t_18, 0, 0, 0);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1142; __pyx_clineno = __LINE__; goto __pyx_L41_except_error;}
+ __PYX_ERR(0, 1155, __pyx_L41_except_error)
}
__pyx_L41_except_error:;
- /* "netCDF4/_netCDF4.pyx":1138
+ /* "netCDF4/_netCDF4.pyx":1151
* except:
* # check if it's an enum
* try: # <<<<<<<<<<<<<<
* type_att = _read_enum(grp, att_type)
* value_arr = numpy.empty(att_len,type_att.dtype)
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_XGIVEREF(__pyx_t_22);
@@ -4912,19 +5063,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
}
__pyx_L31_except_error:;
- /* "netCDF4/_netCDF4.pyx":1133
+ /* "netCDF4/_netCDF4.pyx":1146
* except KeyError:
* # check if it's a compound
* try: # <<<<<<<<<<<<<<
* type_att = _read_compound(grp, att_type)
* value_arr = numpy.empty(att_len,type_att)
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
goto __pyx_L21_except_error;
__pyx_L30_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
@@ -4939,19 +5092,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
goto __pyx_L21_except_error;
__pyx_L21_except_error:;
- /* "netCDF4/_netCDF4.pyx":1128
+ /* "netCDF4/_netCDF4.pyx":1141
* if att_type == NC_LONG:
* att_type = NC_INT
* try: # <<<<<<<<<<<<<<
* type_att = _nctonptype[att_type] # see if it is a primitive type
* value_arr = numpy.empty(att_len,type_att)
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
goto __pyx_L1_error;
__pyx_L20_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_14);
@@ -4959,7 +5114,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_L26_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1143
+ /* "netCDF4/_netCDF4.pyx":1156
* except:
* raise KeyError('attribute %s has unsupported datatype' % attname)
* with nogil: # <<<<<<<<<<<<<<
@@ -4973,7 +5128,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1144
+ /* "netCDF4/_netCDF4.pyx":1157
* raise KeyError('attribute %s has unsupported datatype' % attname)
* with nogil:
* ierr = nc_get_att(_grpid, varid, attname, value_arr.data) # <<<<<<<<<<<<<<
@@ -4983,7 +5138,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_v_ierr = nc_get_att(__pyx_v__grpid, __pyx_v_varid, __pyx_v_attname, __pyx_v_value_arr->data);
}
- /* "netCDF4/_netCDF4.pyx":1143
+ /* "netCDF4/_netCDF4.pyx":1156
* except:
* raise KeyError('attribute %s has unsupported datatype' % attname)
* with nogil: # <<<<<<<<<<<<<<
@@ -5001,7 +5156,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
}
}
- /* "netCDF4/_netCDF4.pyx":1145
+ /* "netCDF4/_netCDF4.pyx":1158
* with nogil:
* ierr = nc_get_att(_grpid, varid, attname, value_arr.data)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -5011,7 +5166,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_4 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":1146
+ /* "netCDF4/_netCDF4.pyx":1159
* ierr = nc_get_att(_grpid, varid, attname, value_arr.data)
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -5019,22 +5174,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* # return a scalar for a scalar array
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_9 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1146; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1159, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1146; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1159, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_9);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1146; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1159, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_9, 0, 0, 0);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1146; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1159, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1145
+ /* "netCDF4/_netCDF4.pyx":1158
* with nogil:
* ierr = nc_get_att(_grpid, varid, attname, value_arr.data)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -5043,22 +5198,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1147
+ /* "netCDF4/_netCDF4.pyx":1160
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if value_arr.shape == (): # <<<<<<<<<<<<<<
* # return a scalar for a scalar array
* return value_arr.item()
*/
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1147; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1160, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_7 = PyObject_RichCompare(__pyx_t_9, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1147; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_RichCompare(__pyx_t_9, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1160, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1147; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 1160, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":1149
+ /* "netCDF4/_netCDF4.pyx":1162
* if value_arr.shape == ():
* # return a scalar for a scalar array
* return value_arr.item() # <<<<<<<<<<<<<<
@@ -5066,7 +5221,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* # return a scalar for a single element array
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_item); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1149; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_item); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1162, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_11 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_9))) {
@@ -5079,10 +5234,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
}
}
if (__pyx_t_11) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_11); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1149; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1162, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1149; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1162, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -5090,7 +5245,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_7 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1147
+ /* "netCDF4/_netCDF4.pyx":1160
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if value_arr.shape == (): # <<<<<<<<<<<<<<
@@ -5099,7 +5254,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1150
+ /* "netCDF4/_netCDF4.pyx":1163
* # return a scalar for a scalar array
* return value_arr.item()
* elif att_len == 1: # <<<<<<<<<<<<<<
@@ -5109,7 +5264,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
__pyx_t_4 = ((__pyx_v_att_len == 1) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":1152
+ /* "netCDF4/_netCDF4.pyx":1165
* elif att_len == 1:
* # return a scalar for a single element array
* return value_arr[0] # <<<<<<<<<<<<<<
@@ -5117,13 +5272,13 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
* return value_arr
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_7 = __Pyx_GetItemInt(((PyObject *)__pyx_v_value_arr), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1152; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = __Pyx_GetItemInt(((PyObject *)__pyx_v_value_arr), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1165, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_r = __pyx_t_7;
__pyx_t_7 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1150
+ /* "netCDF4/_netCDF4.pyx":1163
* # return a scalar for a scalar array
* return value_arr.item()
* elif att_len == 1: # <<<<<<<<<<<<<<
@@ -5132,7 +5287,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1154
+ /* "netCDF4/_netCDF4.pyx":1167
* return value_arr[0]
* else:
* return value_arr # <<<<<<<<<<<<<<
@@ -5148,7 +5303,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
break;
}
- /* "netCDF4/_netCDF4.pyx":1085
+ /* "netCDF4/_netCDF4.pyx":1098
* return attslist
*
* cdef _get_att(grp, int varid, name): # <<<<<<<<<<<<<<
@@ -5182,7 +5337,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_att(PyObject *__pyx_v_grp, int
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1156
+/* "netCDF4/_netCDF4.pyx":1169
* return value_arr
*
* def _set_default_format(object format='NETCDF4'): # <<<<<<<<<<<<<<
@@ -5195,9 +5350,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_5_set_default_format(PyObject *__py
static PyMethodDef __pyx_mdef_7netCDF4_8_netCDF4_5_set_default_format = {"_set_default_format", (PyCFunction)__pyx_pw_7netCDF4_8_netCDF4_5_set_default_format, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_5_set_default_format(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_format = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_set_default_format (wrapper)", 0);
@@ -5222,7 +5374,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_5_set_default_format(PyObject *__py
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_set_default_format") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1156; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_set_default_format") < 0)) __PYX_ERR(0, 1169, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -5235,7 +5387,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_5_set_default_format(PyObject *__py
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("_set_default_format", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1156; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_set_default_format", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1169, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4._set_default_format", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -5256,39 +5408,36 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_4_set_default_format(CYTHON_UNUSED
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
int __pyx_t_5;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_set_default_format", 0);
- /* "netCDF4/_netCDF4.pyx":1158
+ /* "netCDF4/_netCDF4.pyx":1171
* def _set_default_format(object format='NETCDF4'):
* # Private function to set the netCDF file format
* if format not in _format_dict: # <<<<<<<<<<<<<<
* raise ValueError("unrecognized format requested")
* nc_set_default_format(_format_dict[format], NULL)
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1158; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1171, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_format, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1158; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_format, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1171, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1159
+ /* "netCDF4/_netCDF4.pyx":1172
* # Private function to set the netCDF file format
* if format not in _format_dict:
* raise ValueError("unrecognized format requested") # <<<<<<<<<<<<<<
* nc_set_default_format(_format_dict[format], NULL)
*
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1159; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1172, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1159; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1172, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1158
+ /* "netCDF4/_netCDF4.pyx":1171
* def _set_default_format(object format='NETCDF4'):
* # Private function to set the netCDF file format
* if format not in _format_dict: # <<<<<<<<<<<<<<
@@ -5297,23 +5446,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_4_set_default_format(CYTHON_UNUSED
*/
}
- /* "netCDF4/_netCDF4.pyx":1160
+ /* "netCDF4/_netCDF4.pyx":1173
* if format not in _format_dict:
* raise ValueError("unrecognized format requested")
* nc_set_default_format(_format_dict[format], NULL) # <<<<<<<<<<<<<<
*
* cdef _get_format(int grpid):
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1160; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1173, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyObject_GetItem(__pyx_t_1, __pyx_v_format); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1160; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_t_1, __pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1173, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1160; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1173, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
nc_set_default_format(__pyx_t_5, NULL);
- /* "netCDF4/_netCDF4.pyx":1156
+ /* "netCDF4/_netCDF4.pyx":1169
* return value_arr
*
* def _set_default_format(object format='NETCDF4'): # <<<<<<<<<<<<<<
@@ -5335,7 +5484,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_4_set_default_format(CYTHON_UNUSED
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1162
+/* "netCDF4/_netCDF4.pyx":1175
* nc_set_default_format(_format_dict[format], NULL)
*
* cdef _get_format(int grpid): # <<<<<<<<<<<<<<
@@ -5353,12 +5502,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_t_5;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_format", 0);
- /* "netCDF4/_netCDF4.pyx":1165
+ /* "netCDF4/_netCDF4.pyx":1178
* # Private function to get the netCDF file format
* cdef int ierr, formatp
* with nogil: # <<<<<<<<<<<<<<
@@ -5372,7 +5518,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1166
+ /* "netCDF4/_netCDF4.pyx":1179
* cdef int ierr, formatp
* with nogil:
* ierr = nc_inq_format(grpid, &formatp) # <<<<<<<<<<<<<<
@@ -5382,7 +5528,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
__pyx_v_ierr = nc_inq_format(__pyx_v_grpid, (&__pyx_v_formatp));
}
- /* "netCDF4/_netCDF4.pyx":1165
+ /* "netCDF4/_netCDF4.pyx":1178
* # Private function to get the netCDF file format
* cdef int ierr, formatp
* with nogil: # <<<<<<<<<<<<<<
@@ -5400,7 +5546,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
}
}
- /* "netCDF4/_netCDF4.pyx":1167
+ /* "netCDF4/_netCDF4.pyx":1180
* with nogil:
* ierr = nc_inq_format(grpid, &formatp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -5410,7 +5556,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1168
+ /* "netCDF4/_netCDF4.pyx":1181
* ierr = nc_inq_format(grpid, &formatp)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -5418,22 +5564,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
* raise ValueError('format not supported by python interface')
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1168; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1168; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1168; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1168; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1181, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1167
+ /* "netCDF4/_netCDF4.pyx":1180
* with nogil:
* ierr = nc_inq_format(grpid, &formatp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -5442,37 +5588,37 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1169
+ /* "netCDF4/_netCDF4.pyx":1182
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if formatp not in _reverse_format_dict: # <<<<<<<<<<<<<<
* raise ValueError('format not supported by python interface')
* return _reverse_format_dict[formatp]
*/
- __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_formatp); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1169; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_formatp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1182, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_reverse_format_dict); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1169; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_reverse_format_dict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1182, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_t_4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1169; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_t_4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1182, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_5 = (__pyx_t_1 != 0);
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":1170
+ /* "netCDF4/_netCDF4.pyx":1183
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if formatp not in _reverse_format_dict:
* raise ValueError('format not supported by python interface') # <<<<<<<<<<<<<<
* return _reverse_format_dict[formatp]
*
*/
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1170; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1183, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1170; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1183, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1169
+ /* "netCDF4/_netCDF4.pyx":1182
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if formatp not in _reverse_format_dict: # <<<<<<<<<<<<<<
@@ -5481,7 +5627,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1171
+ /* "netCDF4/_netCDF4.pyx":1184
* if formatp not in _reverse_format_dict:
* raise ValueError('format not supported by python interface')
* return _reverse_format_dict[formatp] # <<<<<<<<<<<<<<
@@ -5489,16 +5635,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
* cdef _get_full_format(int grpid):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_reverse_format_dict); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1171; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_reverse_format_dict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1184, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_formatp, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1171; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_formatp, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1184, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1162
+ /* "netCDF4/_netCDF4.pyx":1175
* nc_set_default_format(_format_dict[format], NULL)
*
* cdef _get_format(int grpid): # <<<<<<<<<<<<<<
@@ -5518,7 +5664,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_format(int __pyx_v_grpid) {
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1173
+/* "netCDF4/_netCDF4.pyx":1186
* return _reverse_format_dict[formatp]
*
* cdef _get_full_format(int grpid): # <<<<<<<<<<<<<<
@@ -5531,7 +5677,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_full_format(CYTHON_UNUSED int _
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_full_format", 0);
- /* "netCDF4/_netCDF4.pyx":1196
+ /* "netCDF4/_netCDF4.pyx":1209
* return 'UNDEFINED'
* ELSE:
* return 'UNDEFINED' # <<<<<<<<<<<<<<
@@ -5543,7 +5689,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_full_format(CYTHON_UNUSED int _
__pyx_r = __pyx_n_s_UNDEFINED;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1173
+ /* "netCDF4/_netCDF4.pyx":1186
* return _reverse_format_dict[formatp]
*
* cdef _get_full_format(int grpid): # <<<<<<<<<<<<<<
@@ -5558,7 +5704,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_full_format(CYTHON_UNUSED int _
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1198
+/* "netCDF4/_netCDF4.pyx":1211
* return 'UNDEFINED'
*
* cdef _set_att(grp, int varid, name, value,\ # <<<<<<<<<<<<<<
@@ -5569,7 +5715,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_full_format(CYTHON_UNUSED int _
static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int __pyx_v_varid, PyObject *__pyx_v_name, PyObject *__pyx_v_value, struct __pyx_opt_args_7netCDF4_8_netCDF4__set_att *__pyx_optional_args) {
nc_type __pyx_v_xtype = ((nc_type)-99);
- /* "netCDF4/_netCDF4.pyx":1199
+ /* "netCDF4/_netCDF4.pyx":1212
*
* cdef _set_att(grp, int varid, name, value,\
* nc_type xtype=-99, force_ncstring=False): # <<<<<<<<<<<<<<
@@ -5606,9 +5752,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
nc_type __pyx_t_14;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_set_att", 0);
if (__pyx_optional_args) {
if (__pyx_optional_args->__pyx_n > 0) {
@@ -5619,38 +5762,38 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
}
- /* "netCDF4/_netCDF4.pyx":1207
+ /* "netCDF4/_netCDF4.pyx":1220
* cdef char *datstring
* cdef ndarray value_arr
* bytestr = _strencode(name) # <<<<<<<<<<<<<<
* attname = bytestr
* # put attribute value into a numpy array.
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1207; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1208
+ /* "netCDF4/_netCDF4.pyx":1221
* cdef ndarray value_arr
* bytestr = _strencode(name)
* attname = bytestr # <<<<<<<<<<<<<<
* # put attribute value into a numpy array.
* value_arr = numpy.array(value)
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1208; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 1221, __pyx_L1_error)
__pyx_v_attname = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":1210
+ /* "netCDF4/_netCDF4.pyx":1223
* attname = bytestr
* # put attribute value into a numpy array.
* value_arr = numpy.array(value) # <<<<<<<<<<<<<<
* # if array is 64 bit integers or
* # if 64-bit datatype not supported, cast to 32 bit integers.
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -5664,53 +5807,53 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_value); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_value);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 1223, __pyx_L1_error)
__pyx_v_value_arr = ((PyArrayObject *)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1213
+ /* "netCDF4/_netCDF4.pyx":1226
* # if array is 64 bit integers or
* # if 64-bit datatype not supported, cast to 32 bit integers.
* fmt = _get_format(grp._grpid) # <<<<<<<<<<<<<<
* is_netcdf3 = fmt.startswith('NETCDF3') or fmt == 'NETCDF4_CLASSIC'
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1226, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1226, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_format(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_format(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1226, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_fmt = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1214
+ /* "netCDF4/_netCDF4.pyx":1227
* # if 64-bit datatype not supported, cast to 32 bit integers.
* fmt = _get_format(grp._grpid)
* is_netcdf3 = fmt.startswith('NETCDF3') or fmt == 'NETCDF4_CLASSIC' # <<<<<<<<<<<<<<
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\
* is_netcdf3):
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_fmt, __pyx_n_s_startswith); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_fmt, __pyx_n_s_startswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1227, __pyx_L1_error)
if (!__pyx_t_7) {
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
@@ -5719,7 +5862,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
goto __pyx_L3_bool_binop_done;
}
- __pyx_t_5 = PyObject_RichCompare(__pyx_v_fmt, __pyx_n_s_NETCDF4_CLASSIC, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_RichCompare(__pyx_v_fmt, __pyx_n_s_NETCDF4_CLASSIC, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1227, __pyx_L1_error)
__Pyx_INCREF(__pyx_t_5);
__pyx_t_1 = __pyx_t_5;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -5727,31 +5870,31 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_v_is_netcdf3 = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1215
+ /* "netCDF4/_netCDF4.pyx":1228
* fmt = _get_format(grp._grpid)
* is_netcdf3 = fmt.startswith('NETCDF3') or fmt == 'NETCDF4_CLASSIC'
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\ # <<<<<<<<<<<<<<
* is_netcdf3):
* value_arr = value_arr.astype('i4')
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__9, 1, 0, 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__9, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_i8, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_i8, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1228, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_8) {
} else {
__pyx_t_7 = __pyx_t_8;
goto __pyx_L6_bool_binop_done;
}
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_i8, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_i8, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1228, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_9 = (__pyx_t_8 != 0);
if (!__pyx_t_9) {
@@ -5760,18 +5903,18 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
goto __pyx_L6_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":1216
+ /* "netCDF4/_netCDF4.pyx":1229
* is_netcdf3 = fmt.startswith('NETCDF3') or fmt == 'NETCDF4_CLASSIC'
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\
* is_netcdf3): # <<<<<<<<<<<<<<
* value_arr = value_arr.astype('i4')
* # if array contains ascii strings, write a text attribute (stored as bytes).
*/
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_is_netcdf3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1216; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_is_netcdf3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1229, __pyx_L1_error)
__pyx_t_7 = __pyx_t_9;
__pyx_L6_bool_binop_done:;
- /* "netCDF4/_netCDF4.pyx":1215
+ /* "netCDF4/_netCDF4.pyx":1228
* fmt = _get_format(grp._grpid)
* is_netcdf3 = fmt.startswith('NETCDF3') or fmt == 'NETCDF4_CLASSIC'
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\ # <<<<<<<<<<<<<<
@@ -5780,23 +5923,23 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1217
+ /* "netCDF4/_netCDF4.pyx":1230
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\
* is_netcdf3):
* value_arr = value_arr.astype('i4') # <<<<<<<<<<<<<<
* # if array contains ascii strings, write a text attribute (stored as bytes).
* # if array contains unicode strings, and data model is NETCDF4,
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_astype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_astype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1230, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1230, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 1230, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_value_arr, ((PyArrayObject *)__pyx_t_5));
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":1215
+ /* "netCDF4/_netCDF4.pyx":1228
* fmt = _get_format(grp._grpid)
* is_netcdf3 = fmt.startswith('NETCDF3') or fmt == 'NETCDF4_CLASSIC'
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\ # <<<<<<<<<<<<<<
@@ -5805,53 +5948,53 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1221
+ /* "netCDF4/_netCDF4.pyx":1234
* # if array contains unicode strings, and data model is NETCDF4,
* # write as a string. string arrays are concatenated into a single string.
* if value_arr.dtype.char in ['S','U']: # <<<<<<<<<<<<<<
* if not value_arr.shape:
* dats = _strencode(value_arr.item())
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1221; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1234, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_char); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1221; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_char); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1234, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_S, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1221; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_S, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1234, __pyx_L1_error)
if (!__pyx_t_9) {
} else {
__pyx_t_7 = __pyx_t_9;
goto __pyx_L10_bool_binop_done;
}
- __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_U, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1221; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_U, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1234, __pyx_L1_error)
__pyx_t_7 = __pyx_t_9;
__pyx_L10_bool_binop_done:;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_9 = (__pyx_t_7 != 0);
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":1222
+ /* "netCDF4/_netCDF4.pyx":1235
* # write as a string. string arrays are concatenated into a single string.
* if value_arr.dtype.char in ['S','U']:
* if not value_arr.shape: # <<<<<<<<<<<<<<
* dats = _strencode(value_arr.item())
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1235, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1235, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_7 = ((!__pyx_t_9) != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1223
+ /* "netCDF4/_netCDF4.pyx":1236
* if value_arr.dtype.char in ['S','U']:
* if not value_arr.shape:
* dats = _strencode(value_arr.item()) # <<<<<<<<<<<<<<
* else:
* value_arr1 = value_arr.ravel()
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_item); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1223; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_item); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1236, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -5864,20 +6007,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1223; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1236, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1223; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1236, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1223; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1236, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_dats = __pyx_t_5;
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":1222
+ /* "netCDF4/_netCDF4.pyx":1235
* # write as a string. string arrays are concatenated into a single string.
* if value_arr.dtype.char in ['S','U']:
* if not value_arr.shape: # <<<<<<<<<<<<<<
@@ -5887,7 +6030,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
goto __pyx_L12;
}
- /* "netCDF4/_netCDF4.pyx":1225
+ /* "netCDF4/_netCDF4.pyx":1238
* dats = _strencode(value_arr.item())
* else:
* value_arr1 = value_arr.ravel() # <<<<<<<<<<<<<<
@@ -5895,7 +6038,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
* lenarr = len(dats)
*/
/*else*/ {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_ravel); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_ravel); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1238, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -5908,24 +6051,24 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
}
if (__pyx_t_4) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1238, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1238, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_value_arr1 = __pyx_t_5;
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":1226
+ /* "netCDF4/_netCDF4.pyx":1239
* else:
* value_arr1 = value_arr.ravel()
* dats = _strencode(''.join(value_arr1.tolist())) # <<<<<<<<<<<<<<
* lenarr = len(dats)
* datstring = dats
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_value_arr1, __pyx_n_s_tolist); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1226; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_value_arr1, __pyx_n_s_tolist); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1239, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -5938,17 +6081,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
}
if (__pyx_t_4) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1226; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1239, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1226; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1239, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1226; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1239, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1226; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1239, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_dats = __pyx_t_5;
@@ -5956,27 +6099,27 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
__pyx_L12:;
- /* "netCDF4/_netCDF4.pyx":1227
+ /* "netCDF4/_netCDF4.pyx":1240
* value_arr1 = value_arr.ravel()
* dats = _strencode(''.join(value_arr1.tolist()))
* lenarr = len(dats) # <<<<<<<<<<<<<<
* datstring = dats
* if lenarr == 0:
*/
- __pyx_t_10 = PyObject_Length(__pyx_v_dats); if (unlikely(__pyx_t_10 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1227; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyObject_Length(__pyx_v_dats); if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 1240, __pyx_L1_error)
__pyx_v_lenarr = __pyx_t_10;
- /* "netCDF4/_netCDF4.pyx":1228
+ /* "netCDF4/_netCDF4.pyx":1241
* dats = _strencode(''.join(value_arr1.tolist()))
* lenarr = len(dats)
* datstring = dats # <<<<<<<<<<<<<<
* if lenarr == 0:
* # write null byte
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_dats); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1228; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_dats); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 1241, __pyx_L1_error)
__pyx_v_datstring = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":1229
+ /* "netCDF4/_netCDF4.pyx":1242
* lenarr = len(dats)
* datstring = dats
* if lenarr == 0: # <<<<<<<<<<<<<<
@@ -5986,7 +6129,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_t_7 = ((__pyx_v_lenarr == 0) != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1231
+ /* "netCDF4/_netCDF4.pyx":1244
* if lenarr == 0:
* # write null byte
* lenarr=1; datstring = '\x00' # <<<<<<<<<<<<<<
@@ -5994,9 +6137,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
* # check to see if attribute already exists
*/
__pyx_v_lenarr = 1;
- __pyx_v_datstring = __pyx_k_;
+ __pyx_v_datstring = ((char *)"\000");
- /* "netCDF4/_netCDF4.pyx":1229
+ /* "netCDF4/_netCDF4.pyx":1242
* lenarr = len(dats)
* datstring = dats
* if lenarr == 0: # <<<<<<<<<<<<<<
@@ -6005,24 +6148,24 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1232
+ /* "netCDF4/_netCDF4.pyx":1245
* # write null byte
* lenarr=1; datstring = '\x00'
* if (force_ncstring or value_arr.dtype.char == 'U') and not is_netcdf3: # <<<<<<<<<<<<<<
* # check to see if attribute already exists
* # and is NC_CHAR, if so delete it and re-create it
*/
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_force_ncstring); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_force_ncstring); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1245, __pyx_L1_error)
if (!__pyx_t_9) {
} else {
goto __pyx_L16_next_and;
}
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1245, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_char); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_char); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1245, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_U, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_U, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1245, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_9) {
} else {
@@ -6030,39 +6173,39 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
goto __pyx_L15_bool_binop_done;
}
__pyx_L16_next_and:;
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_is_netcdf3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_is_netcdf3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1245, __pyx_L1_error)
__pyx_t_8 = ((!__pyx_t_9) != 0);
__pyx_t_7 = __pyx_t_8;
__pyx_L15_bool_binop_done:;
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1238
+ /* "netCDF4/_netCDF4.pyx":1251
* # with commit 473259b7728120bb281c52359b1af50cca2fcb72,
* # which was included in 4.4.0-RC5.
* if _needsworkaround_issue485: # <<<<<<<<<<<<<<
* ierr = nc_inq_att(grp._grpid, varid, attname, &att_type, &att_len)
* if ierr == NC_NOERR and att_type == NC_CHAR:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_needsworkaround_issue485); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_needsworkaround_issue485); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1251, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1239
+ /* "netCDF4/_netCDF4.pyx":1252
* # which was included in 4.4.0-RC5.
* if _needsworkaround_issue485:
* ierr = nc_inq_att(grp._grpid, varid, attname, &att_type, &att_len) # <<<<<<<<<<<<<<
* if ierr == NC_NOERR and att_type == NC_CHAR:
* ierr = nc_del_att(grp._grpid, varid, attname)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1239; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1252, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1239; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1252, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_ierr = nc_inq_att(__pyx_t_6, __pyx_v_varid, __pyx_v_attname, (&__pyx_v_att_type), (&__pyx_v_att_len));
- /* "netCDF4/_netCDF4.pyx":1240
+ /* "netCDF4/_netCDF4.pyx":1253
* if _needsworkaround_issue485:
* ierr = nc_inq_att(grp._grpid, varid, attname, &att_type, &att_len)
* if ierr == NC_NOERR and att_type == NC_CHAR: # <<<<<<<<<<<<<<
@@ -6080,20 +6223,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_L20_bool_binop_done:;
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1241
+ /* "netCDF4/_netCDF4.pyx":1254
* ierr = nc_inq_att(grp._grpid, varid, attname, &att_type, &att_len)
* if ierr == NC_NOERR and att_type == NC_CHAR:
* ierr = nc_del_att(grp._grpid, varid, attname) # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1241; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1241; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1254, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_ierr = nc_del_att(__pyx_t_6, __pyx_v_varid, __pyx_v_attname);
- /* "netCDF4/_netCDF4.pyx":1242
+ /* "netCDF4/_netCDF4.pyx":1255
* if ierr == NC_NOERR and att_type == NC_CHAR:
* ierr = nc_del_att(grp._grpid, varid, attname)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6103,7 +6246,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_t_7 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1243
+ /* "netCDF4/_netCDF4.pyx":1256
* ierr = nc_del_att(grp._grpid, varid, attname)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -6111,22 +6254,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
* # else it's a unicode string, write as NC_STRING (if NETCDF4)
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1256, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1256, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1256, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1256, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1242
+ /* "netCDF4/_netCDF4.pyx":1255
* if ierr == NC_NOERR and att_type == NC_CHAR:
* ierr = nc_del_att(grp._grpid, varid, attname)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6135,7 +6278,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1240
+ /* "netCDF4/_netCDF4.pyx":1253
* if _needsworkaround_issue485:
* ierr = nc_inq_att(grp._grpid, varid, attname, &att_type, &att_len)
* if ierr == NC_NOERR and att_type == NC_CHAR: # <<<<<<<<<<<<<<
@@ -6144,7 +6287,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1238
+ /* "netCDF4/_netCDF4.pyx":1251
* # with commit 473259b7728120bb281c52359b1af50cca2fcb72,
* # which was included in 4.4.0-RC5.
* if _needsworkaround_issue485: # <<<<<<<<<<<<<<
@@ -6153,7 +6296,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1246
+ /* "netCDF4/_netCDF4.pyx":1259
* # try to convert to ascii string, write as NC_CHAR
* # else it's a unicode string, write as NC_STRING (if NETCDF4)
* try: # <<<<<<<<<<<<<<
@@ -6161,33 +6304,35 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
* dats_ascii = _to_ascii(dats) # try to encode bytes as ascii string
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_13);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1247
+ /* "netCDF4/_netCDF4.pyx":1260
* # else it's a unicode string, write as NC_STRING (if NETCDF4)
* try:
* if force_ncstring: raise UnicodeError # <<<<<<<<<<<<<<
* dats_ascii = _to_ascii(dats) # try to encode bytes as ascii string
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring)
*/
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_force_ncstring); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1247; __pyx_clineno = __LINE__; goto __pyx_L23_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_force_ncstring); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1260, __pyx_L23_error)
if (__pyx_t_7) {
__Pyx_Raise(__pyx_builtin_UnicodeError, 0, 0, 0);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1247; __pyx_clineno = __LINE__; goto __pyx_L23_error;}
+ __PYX_ERR(0, 1260, __pyx_L23_error)
}
- /* "netCDF4/_netCDF4.pyx":1248
+ /* "netCDF4/_netCDF4.pyx":1261
* try:
* if force_ncstring: raise UnicodeError
* dats_ascii = _to_ascii(dats) # try to encode bytes as ascii string # <<<<<<<<<<<<<<
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring)
* except UnicodeError:
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_to_ascii); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1248; __pyx_clineno = __LINE__; goto __pyx_L23_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_to_ascii); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1261, __pyx_L23_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
@@ -6200,16 +6345,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
}
if (!__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_dats); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1248; __pyx_clineno = __LINE__; goto __pyx_L23_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_dats); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1261, __pyx_L23_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1248; __pyx_clineno = __LINE__; goto __pyx_L23_error;}
+ __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1261, __pyx_L23_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_dats);
__Pyx_GIVEREF(__pyx_v_dats);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_dats);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1248; __pyx_clineno = __LINE__; goto __pyx_L23_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1261, __pyx_L23_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
@@ -6217,20 +6362,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_v_dats_ascii = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1249
+ /* "netCDF4/_netCDF4.pyx":1262
* if force_ncstring: raise UnicodeError
* dats_ascii = _to_ascii(dats) # try to encode bytes as ascii string
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring) # <<<<<<<<<<<<<<
* except UnicodeError:
* ierr = nc_put_att_string(grp._grpid, varid, attname, 1, &datstring)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1249; __pyx_clineno = __LINE__; goto __pyx_L23_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1262, __pyx_L23_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1249; __pyx_clineno = __LINE__; goto __pyx_L23_error;}
+ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1262, __pyx_L23_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_ierr = nc_put_att_text(__pyx_t_6, __pyx_v_varid, __pyx_v_attname, __pyx_v_lenarr, __pyx_v_datstring);
- /* "netCDF4/_netCDF4.pyx":1246
+ /* "netCDF4/_netCDF4.pyx":1259
* # try to convert to ascii string, write as NC_CHAR
* # else it's a unicode string, write as NC_STRING (if NETCDF4)
* try: # <<<<<<<<<<<<<<
@@ -6243,36 +6388,37 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
goto __pyx_L30_try_end;
__pyx_L23_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1250
+ /* "netCDF4/_netCDF4.pyx":1263
* dats_ascii = _to_ascii(dats) # try to encode bytes as ascii string
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring)
* except UnicodeError: # <<<<<<<<<<<<<<
* ierr = nc_put_att_string(grp._grpid, varid, attname, 1, &datstring)
* else:
*/
- __pyx_t_6 = PyErr_ExceptionMatches(__pyx_builtin_UnicodeError);
+ __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeError);
if (__pyx_t_6) {
__Pyx_AddTraceback("netCDF4._netCDF4._set_att", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1250; __pyx_clineno = __LINE__; goto __pyx_L25_except_error;}
+ if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_3) < 0) __PYX_ERR(0, 1263, __pyx_L25_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_3);
- /* "netCDF4/_netCDF4.pyx":1251
+ /* "netCDF4/_netCDF4.pyx":1264
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring)
* except UnicodeError:
* ierr = nc_put_att_string(grp._grpid, varid, attname, 1, &datstring) # <<<<<<<<<<<<<<
* else:
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring)
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1251; __pyx_clineno = __LINE__; goto __pyx_L25_except_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1264, __pyx_L25_except_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1251; __pyx_clineno = __LINE__; goto __pyx_L25_except_error;}
+ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1264, __pyx_L25_except_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_ierr = nc_put_att_string(__pyx_t_6, __pyx_v_varid, __pyx_v_attname, 1, (&__pyx_v_datstring));
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -6283,19 +6429,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
goto __pyx_L25_except_error;
__pyx_L25_except_error:;
- /* "netCDF4/_netCDF4.pyx":1246
+ /* "netCDF4/_netCDF4.pyx":1259
* # try to convert to ascii string, write as NC_CHAR
* # else it's a unicode string, write as NC_STRING (if NETCDF4)
* try: # <<<<<<<<<<<<<<
* if force_ncstring: raise UnicodeError
* dats_ascii = _to_ascii(dats) # try to encode bytes as ascii string
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
goto __pyx_L1_error;
__pyx_L24_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
@@ -6303,7 +6451,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_L30_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1232
+ /* "netCDF4/_netCDF4.pyx":1245
* # write null byte
* lenarr=1; datstring = '\x00'
* if (force_ncstring or value_arr.dtype.char == 'U') and not is_netcdf3: # <<<<<<<<<<<<<<
@@ -6313,7 +6461,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
goto __pyx_L14;
}
- /* "netCDF4/_netCDF4.pyx":1253
+ /* "netCDF4/_netCDF4.pyx":1266
* ierr = nc_put_att_string(grp._grpid, varid, attname, 1, &datstring)
* else:
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring) # <<<<<<<<<<<<<<
@@ -6321,15 +6469,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1266, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_ierr = nc_put_att_text(__pyx_t_6, __pyx_v_varid, __pyx_v_attname, __pyx_v_lenarr, __pyx_v_datstring);
}
__pyx_L14:;
- /* "netCDF4/_netCDF4.pyx":1254
+ /* "netCDF4/_netCDF4.pyx":1267
* else:
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6339,7 +6487,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_t_7 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1255
+ /* "netCDF4/_netCDF4.pyx":1268
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring)
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -6347,22 +6495,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
* else:
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1255; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1268, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1255; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1268, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1255; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1268, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1255; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1268, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1254
+ /* "netCDF4/_netCDF4.pyx":1267
* else:
* ierr = nc_put_att_text(grp._grpid, varid, attname, lenarr, datstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6371,7 +6519,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1221
+ /* "netCDF4/_netCDF4.pyx":1234
* # if array contains unicode strings, and data model is NETCDF4,
* # write as a string. string arrays are concatenated into a single string.
* if value_arr.dtype.char in ['S','U']: # <<<<<<<<<<<<<<
@@ -6381,7 +6529,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":1258
+ /* "netCDF4/_netCDF4.pyx":1271
* # a 'regular' array type ('f4','i4','f8' etc)
* else:
* if value_arr.dtype.kind == 'V': # compound attribute. # <<<<<<<<<<<<<<
@@ -6389,32 +6537,32 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
* elif value_arr.dtype.str[1:] not in _supportedtypes:
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1258; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1271, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1258; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1271, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_V, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1258; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_V, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1271, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":1259
+ /* "netCDF4/_netCDF4.pyx":1272
* else:
* if value_arr.dtype.kind == 'V': # compound attribute.
* xtype = _find_cmptype(grp,value_arr.dtype) # <<<<<<<<<<<<<<
* elif value_arr.dtype.str[1:] not in _supportedtypes:
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:])
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__find_cmptype(__pyx_v_grp, __pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__find_cmptype(__pyx_v_grp, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_14 = __Pyx_PyInt_As_nc_type(__pyx_t_3); if (unlikely((__pyx_t_14 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyInt_As_nc_type(__pyx_t_3); if (unlikely((__pyx_t_14 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 1272, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_xtype = __pyx_t_14;
- /* "netCDF4/_netCDF4.pyx":1258
+ /* "netCDF4/_netCDF4.pyx":1271
* # a 'regular' array type ('f4','i4','f8' etc)
* else:
* if value_arr.dtype.kind == 'V': # compound attribute. # <<<<<<<<<<<<<<
@@ -6424,47 +6572,47 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
goto __pyx_L35;
}
- /* "netCDF4/_netCDF4.pyx":1260
+ /* "netCDF4/_netCDF4.pyx":1273
* if value_arr.dtype.kind == 'V': # compound attribute.
* xtype = _find_cmptype(grp,value_arr.dtype)
* elif value_arr.dtype.str[1:] not in _supportedtypes: # <<<<<<<<<<<<<<
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:])
* elif xtype == -99: # if xtype is not passed in as kwarg.
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1260; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1273, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1260; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1273, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__11, 1, 0, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1260; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__11, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1273, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1260; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1273, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_t_5, Py_NE)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1260; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_t_5, Py_NE)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 1273, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_8 = (__pyx_t_7 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":1261
+ /* "netCDF4/_netCDF4.pyx":1274
* xtype = _find_cmptype(grp,value_arr.dtype)
* elif value_arr.dtype.str[1:] not in _supportedtypes:
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:]) # <<<<<<<<<<<<<<
* elif xtype == -99: # if xtype is not passed in as kwarg.
* xtype = _nptonctype[value_arr.dtype.str[1:]]
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_str); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_str); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_1, 1, 0, NULL, NULL, &__pyx_slice__12, 1, 0, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_1, 1, 0, NULL, NULL, &__pyx_slice__12, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5);
@@ -6472,14 +6620,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3);
__pyx_t_5 = 0;
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_illegal_data_type_for_attribute, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_illegal_data_type_for_attribute, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_builtin_TypeError, __pyx_t_3, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1274, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1260
+ /* "netCDF4/_netCDF4.pyx":1273
* if value_arr.dtype.kind == 'V': # compound attribute.
* xtype = _find_cmptype(grp,value_arr.dtype)
* elif value_arr.dtype.str[1:] not in _supportedtypes: # <<<<<<<<<<<<<<
@@ -6488,7 +6636,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
}
- /* "netCDF4/_netCDF4.pyx":1262
+ /* "netCDF4/_netCDF4.pyx":1275
* elif value_arr.dtype.str[1:] not in _supportedtypes:
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:])
* elif xtype == -99: # if xtype is not passed in as kwarg. # <<<<<<<<<<<<<<
@@ -6498,32 +6646,32 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_t_8 = ((__pyx_v_xtype == -99L) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":1263
+ /* "netCDF4/_netCDF4.pyx":1276
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:])
* elif xtype == -99: # if xtype is not passed in as kwarg.
* xtype = _nptonctype[value_arr.dtype.str[1:]] # <<<<<<<<<<<<<<
* lenarr = PyArray_SIZE(value_arr)
* ierr = nc_put_att(grp._grpid, varid, attname, xtype, lenarr, value_arr.data)
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_value_arr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__13, 1, 0, 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__13, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyObject_GetItem(__pyx_t_3, __pyx_t_1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1263; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = PyObject_GetItem(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_14 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_14 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_14 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 1276, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_xtype = __pyx_t_14;
- /* "netCDF4/_netCDF4.pyx":1262
+ /* "netCDF4/_netCDF4.pyx":1275
* elif value_arr.dtype.str[1:] not in _supportedtypes:
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:])
* elif xtype == -99: # if xtype is not passed in as kwarg. # <<<<<<<<<<<<<<
@@ -6533,7 +6681,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
__pyx_L35:;
- /* "netCDF4/_netCDF4.pyx":1264
+ /* "netCDF4/_netCDF4.pyx":1277
* elif xtype == -99: # if xtype is not passed in as kwarg.
* xtype = _nptonctype[value_arr.dtype.str[1:]]
* lenarr = PyArray_SIZE(value_arr) # <<<<<<<<<<<<<<
@@ -6542,20 +6690,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
*/
__pyx_v_lenarr = PyArray_SIZE(__pyx_v_value_arr);
- /* "netCDF4/_netCDF4.pyx":1265
+ /* "netCDF4/_netCDF4.pyx":1278
* xtype = _nptonctype[value_arr.dtype.str[1:]]
* lenarr = PyArray_SIZE(value_arr)
* ierr = nc_put_att(grp._grpid, varid, attname, xtype, lenarr, value_arr.data) # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1265; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1278, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1265; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1278, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_ierr = nc_put_att(__pyx_t_6, __pyx_v_varid, __pyx_v_attname, __pyx_v_xtype, __pyx_v_lenarr, __pyx_v_value_arr->data);
- /* "netCDF4/_netCDF4.pyx":1266
+ /* "netCDF4/_netCDF4.pyx":1279
* lenarr = PyArray_SIZE(value_arr)
* ierr = nc_put_att(grp._grpid, varid, attname, xtype, lenarr, value_arr.data)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6565,7 +6713,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
__pyx_t_8 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":1267
+ /* "netCDF4/_netCDF4.pyx":1280
* ierr = nc_put_att(grp._grpid, varid, attname, xtype, lenarr, value_arr.data)
* if ierr != NC_NOERR:
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -6573,22 +6721,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
* cdef _get_types(group):
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_5 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1267; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1280, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1267; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1280, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1267; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1280, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1267; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1280, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1266
+ /* "netCDF4/_netCDF4.pyx":1279
* lenarr = PyArray_SIZE(value_arr)
* ierr = nc_put_att(grp._grpid, varid, attname, xtype, lenarr, value_arr.data)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6599,7 +6747,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
}
__pyx_L9:;
- /* "netCDF4/_netCDF4.pyx":1198
+ /* "netCDF4/_netCDF4.pyx":1211
* return 'UNDEFINED'
*
* cdef _set_att(grp, int varid, name, value,\ # <<<<<<<<<<<<<<
@@ -6630,7 +6778,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__set_att(PyObject *__pyx_v_grp, int
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1269
+/* "netCDF4/_netCDF4.pyx":1282
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* cdef _get_types(group): # <<<<<<<<<<<<<<
@@ -6672,25 +6820,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
PyObject *__pyx_t_13 = NULL;
int __pyx_t_14;
PyObject *__pyx_t_15 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_types", 0);
- /* "netCDF4/_netCDF4.pyx":1277
+ /* "netCDF4/_netCDF4.pyx":1290
* cdef nc_type *typeids
* cdef char namstring[NC_MAX_NAME+1]
* _grpid = group._grpid # <<<<<<<<<<<<<<
* # get the number of user defined types in this group.
* with nogil:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1277; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1290, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1277; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1290, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":1279
+ /* "netCDF4/_netCDF4.pyx":1292
* _grpid = group._grpid
* # get the number of user defined types in this group.
* with nogil: # <<<<<<<<<<<<<<
@@ -6704,7 +6849,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1280
+ /* "netCDF4/_netCDF4.pyx":1293
* # get the number of user defined types in this group.
* with nogil:
* ierr = nc_inq_typeids(_grpid, &ntypes, NULL) # <<<<<<<<<<<<<<
@@ -6714,7 +6859,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_v_ierr = nc_inq_typeids(__pyx_v__grpid, (&__pyx_v_ntypes), NULL);
}
- /* "netCDF4/_netCDF4.pyx":1279
+ /* "netCDF4/_netCDF4.pyx":1292
* _grpid = group._grpid
* # get the number of user defined types in this group.
* with nogil: # <<<<<<<<<<<<<<
@@ -6732,7 +6877,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
- /* "netCDF4/_netCDF4.pyx":1281
+ /* "netCDF4/_netCDF4.pyx":1294
* with nogil:
* ierr = nc_inq_typeids(_grpid, &ntypes, NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6742,7 +6887,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1282
+ /* "netCDF4/_netCDF4.pyx":1295
* ierr = nc_inq_typeids(_grpid, &ntypes, NULL)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -6750,22 +6895,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
* typeids = <nc_type *>malloc(sizeof(nc_type) * ntypes)
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1282; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1295, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1282; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1295, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1282; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1295, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1282; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1295, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1281
+ /* "netCDF4/_netCDF4.pyx":1294
* with nogil:
* ierr = nc_inq_typeids(_grpid, &ntypes, NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6774,7 +6919,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
}
- /* "netCDF4/_netCDF4.pyx":1283
+ /* "netCDF4/_netCDF4.pyx":1296
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ntypes > 0: # <<<<<<<<<<<<<<
@@ -6784,7 +6929,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_3 = ((__pyx_v_ntypes > 0) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1284
+ /* "netCDF4/_netCDF4.pyx":1297
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ntypes > 0:
* typeids = <nc_type *>malloc(sizeof(nc_type) * ntypes) # <<<<<<<<<<<<<<
@@ -6793,7 +6938,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
__pyx_v_typeids = ((nc_type *)malloc(((sizeof(nc_type)) * __pyx_v_ntypes)));
- /* "netCDF4/_netCDF4.pyx":1285
+ /* "netCDF4/_netCDF4.pyx":1298
* if ntypes > 0:
* typeids = <nc_type *>malloc(sizeof(nc_type) * ntypes)
* with nogil: # <<<<<<<<<<<<<<
@@ -6807,7 +6952,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1286
+ /* "netCDF4/_netCDF4.pyx":1299
* typeids = <nc_type *>malloc(sizeof(nc_type) * ntypes)
* with nogil:
* ierr = nc_inq_typeids(_grpid, &ntypes, typeids) # <<<<<<<<<<<<<<
@@ -6817,7 +6962,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_v_ierr = nc_inq_typeids(__pyx_v__grpid, (&__pyx_v_ntypes), __pyx_v_typeids);
}
- /* "netCDF4/_netCDF4.pyx":1285
+ /* "netCDF4/_netCDF4.pyx":1298
* if ntypes > 0:
* typeids = <nc_type *>malloc(sizeof(nc_type) * ntypes)
* with nogil: # <<<<<<<<<<<<<<
@@ -6835,7 +6980,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
- /* "netCDF4/_netCDF4.pyx":1287
+ /* "netCDF4/_netCDF4.pyx":1300
* with nogil:
* ierr = nc_inq_typeids(_grpid, &ntypes, typeids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6845,7 +6990,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1288
+ /* "netCDF4/_netCDF4.pyx":1301
* ierr = nc_inq_typeids(_grpid, &ntypes, typeids)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -6853,22 +6998,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
* cmptypes = OrderedDict()
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1288; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1301, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1288; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1301, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1288; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1301, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1288; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1301, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1287
+ /* "netCDF4/_netCDF4.pyx":1300
* with nogil:
* ierr = nc_inq_typeids(_grpid, &ntypes, typeids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -6877,7 +7022,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
}
- /* "netCDF4/_netCDF4.pyx":1283
+ /* "netCDF4/_netCDF4.pyx":1296
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ntypes > 0: # <<<<<<<<<<<<<<
@@ -6886,14 +7031,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
}
- /* "netCDF4/_netCDF4.pyx":1290
+ /* "netCDF4/_netCDF4.pyx":1303
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # create empty dictionary for CompoundType instances.
* cmptypes = OrderedDict() # <<<<<<<<<<<<<<
* vltypes = OrderedDict()
* enumtypes = OrderedDict()
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1290; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1303, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
@@ -6906,24 +7051,24 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1290; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1303, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1290; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1303, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_cmptypes = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1291
+ /* "netCDF4/_netCDF4.pyx":1304
* # create empty dictionary for CompoundType instances.
* cmptypes = OrderedDict()
* vltypes = OrderedDict() # <<<<<<<<<<<<<<
* enumtypes = OrderedDict()
* if ntypes > 0:
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1291; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1304, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
@@ -6936,24 +7081,24 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1291; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1304, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1291; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1304, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_vltypes = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1292
+ /* "netCDF4/_netCDF4.pyx":1305
* cmptypes = OrderedDict()
* vltypes = OrderedDict()
* enumtypes = OrderedDict() # <<<<<<<<<<<<<<
* if ntypes > 0:
* for n from 0 <= n < ntypes:
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1305, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
@@ -6966,17 +7111,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1305, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1305, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_enumtypes = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1293
+ /* "netCDF4/_netCDF4.pyx":1306
* vltypes = OrderedDict()
* enumtypes = OrderedDict()
* if ntypes > 0: # <<<<<<<<<<<<<<
@@ -6986,7 +7131,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_3 = ((__pyx_v_ntypes > 0) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1294
+ /* "netCDF4/_netCDF4.pyx":1307
* enumtypes = OrderedDict()
* if ntypes > 0:
* for n from 0 <= n < ntypes: # <<<<<<<<<<<<<<
@@ -6996,7 +7141,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_2 = __pyx_v_ntypes;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_2; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":1295
+ /* "netCDF4/_netCDF4.pyx":1308
* if ntypes > 0:
* for n from 0 <= n < ntypes:
* xtype = typeids[n] # <<<<<<<<<<<<<<
@@ -7005,7 +7150,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
__pyx_v_xtype = (__pyx_v_typeids[__pyx_v_n]);
- /* "netCDF4/_netCDF4.pyx":1296
+ /* "netCDF4/_netCDF4.pyx":1309
* for n from 0 <= n < ntypes:
* xtype = typeids[n]
* with nogil: # <<<<<<<<<<<<<<
@@ -7019,7 +7164,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1297
+ /* "netCDF4/_netCDF4.pyx":1310
* xtype = typeids[n]
* with nogil:
* ierr = nc_inq_user_type(_grpid, xtype, namstring, # <<<<<<<<<<<<<<
@@ -7029,7 +7174,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_v_ierr = nc_inq_user_type(__pyx_v__grpid, __pyx_v_xtype, __pyx_v_namstring, NULL, NULL, NULL, (&__pyx_v_classp));
}
- /* "netCDF4/_netCDF4.pyx":1296
+ /* "netCDF4/_netCDF4.pyx":1309
* for n from 0 <= n < ntypes:
* xtype = typeids[n]
* with nogil: # <<<<<<<<<<<<<<
@@ -7047,7 +7192,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
- /* "netCDF4/_netCDF4.pyx":1299
+ /* "netCDF4/_netCDF4.pyx":1312
* ierr = nc_inq_user_type(_grpid, xtype, namstring,
* NULL,NULL,NULL,&classp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -7057,7 +7202,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1300
+ /* "netCDF4/_netCDF4.pyx":1313
* NULL,NULL,NULL,&classp)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -7065,22 +7210,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
* name = namstring.decode(default_encoding,unicode_error)
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1313, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1313, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1313, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1313, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1299
+ /* "netCDF4/_netCDF4.pyx":1312
* ierr = nc_inq_user_type(_grpid, xtype, namstring,
* NULL,NULL,NULL,&classp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -7089,7 +7234,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
}
- /* "netCDF4/_netCDF4.pyx":1301
+ /* "netCDF4/_netCDF4.pyx":1314
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if classp == NC_COMPOUND: # a compound # <<<<<<<<<<<<<<
@@ -7099,21 +7244,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
switch (__pyx_v_classp) {
case NC_COMPOUND:
- /* "netCDF4/_netCDF4.pyx":1302
+ /* "netCDF4/_netCDF4.pyx":1315
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if classp == NC_COMPOUND: # a compound
* name = namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
* # read the compound type info from the file,
* # create a CompoundType instance from it.
*/
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1315, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1315, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1315, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1315, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -7127,7 +7272,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1315, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -7138,14 +7283,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1315, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1305
+ /* "netCDF4/_netCDF4.pyx":1318
* # read the compound type info from the file,
* # create a CompoundType instance from it.
* try: # <<<<<<<<<<<<<<
@@ -7153,25 +7298,27 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_13);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1306
+ /* "netCDF4/_netCDF4.pyx":1319
* # create a CompoundType instance from it.
* try:
* cmptype = _read_compound(group, xtype) # <<<<<<<<<<<<<<
* except KeyError:
* msg='WARNING: unsupported Compound type, skipping...'
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__read_compound(__pyx_v_group, __pyx_v_xtype, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1306; __pyx_clineno = __LINE__; goto __pyx_L21_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__read_compound(__pyx_v_group, __pyx_v_xtype, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1319, __pyx_L21_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_cmptype, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1305
+ /* "netCDF4/_netCDF4.pyx":1318
* # read the compound type info from the file,
* # create a CompoundType instance from it.
* try: # <<<<<<<<<<<<<<
@@ -7184,6 +7331,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
goto __pyx_L28_try_end;
__pyx_L21_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -7191,22 +7339,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1307
+ /* "netCDF4/_netCDF4.pyx":1320
* try:
* cmptype = _read_compound(group, xtype)
* except KeyError: # <<<<<<<<<<<<<<
* msg='WARNING: unsupported Compound type, skipping...'
* warnings.warn(msg)
*/
- __pyx_t_14 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_14) {
__Pyx_AddTraceback("netCDF4._netCDF4._get_types", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1307; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;}
+ if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_10) < 0) __PYX_ERR(0, 1320, __pyx_L23_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_10);
- /* "netCDF4/_netCDF4.pyx":1308
+ /* "netCDF4/_netCDF4.pyx":1321
* cmptype = _read_compound(group, xtype)
* except KeyError:
* msg='WARNING: unsupported Compound type, skipping...' # <<<<<<<<<<<<<<
@@ -7216,16 +7364,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_INCREF(__pyx_kp_s_WARNING_unsupported_Compound_typ);
__Pyx_XDECREF_SET(__pyx_v_msg, __pyx_kp_s_WARNING_unsupported_Compound_typ);
- /* "netCDF4/_netCDF4.pyx":1309
+ /* "netCDF4/_netCDF4.pyx":1322
* except KeyError:
* msg='WARNING: unsupported Compound type, skipping...'
* warnings.warn(msg) # <<<<<<<<<<<<<<
* continue
* cmptypes[name] = cmptype
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1309; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1322, __pyx_L23_except_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1309; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1322, __pyx_L23_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = NULL;
@@ -7239,23 +7387,23 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
if (!__pyx_t_5) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_msg); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1309; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_msg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1322, __pyx_L23_except_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1309; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;}
+ __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1322, __pyx_L23_except_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_v_msg);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_15, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1309; __pyx_clineno = __LINE__; goto __pyx_L23_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_15, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1322, __pyx_L23_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":1310
+ /* "netCDF4/_netCDF4.pyx":1323
* msg='WARNING: unsupported Compound type, skipping...'
* warnings.warn(msg)
* continue # <<<<<<<<<<<<<<
@@ -7272,19 +7420,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
goto __pyx_L23_except_error;
__pyx_L23_except_error:;
- /* "netCDF4/_netCDF4.pyx":1305
+ /* "netCDF4/_netCDF4.pyx":1318
* # read the compound type info from the file,
* # create a CompoundType instance from it.
* try: # <<<<<<<<<<<<<<
* cmptype = _read_compound(group, xtype)
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
goto __pyx_L1_error;
__pyx_L27_try_continue:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
@@ -7293,16 +7443,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_L28_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1311
+ /* "netCDF4/_netCDF4.pyx":1324
* warnings.warn(msg)
* continue
* cmptypes[name] = cmptype # <<<<<<<<<<<<<<
* elif classp == NC_VLEN: # a vlen
* name = namstring.decode(default_encoding,unicode_error)
*/
- if (unlikely(PyObject_SetItem(__pyx_v_cmptypes, __pyx_v_name, __pyx_v_cmptype) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1311; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_cmptypes, __pyx_v_name, __pyx_v_cmptype) < 0)) __PYX_ERR(0, 1324, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1301
+ /* "netCDF4/_netCDF4.pyx":1314
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if classp == NC_COMPOUND: # a compound # <<<<<<<<<<<<<<
@@ -7311,7 +7461,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
break;
- /* "netCDF4/_netCDF4.pyx":1312
+ /* "netCDF4/_netCDF4.pyx":1325
* continue
* cmptypes[name] = cmptype
* elif classp == NC_VLEN: # a vlen # <<<<<<<<<<<<<<
@@ -7320,21 +7470,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
case NC_VLEN:
- /* "netCDF4/_netCDF4.pyx":1313
+ /* "netCDF4/_netCDF4.pyx":1326
* cmptypes[name] = cmptype
* elif classp == NC_VLEN: # a vlen
* name = namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
* # read the VLEN type info from the file,
* # create a VLType instance from it.
*/
- __pyx_t_6 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1326, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1326, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1326, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1326, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -7348,7 +7498,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_9 = 1;
}
}
- __pyx_t_15 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1326, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -7359,14 +7509,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_6 = 0;
__pyx_t_7 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1326, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_10);
__pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":1316
+ /* "netCDF4/_netCDF4.pyx":1329
* # read the VLEN type info from the file,
* # create a VLType instance from it.
* try: # <<<<<<<<<<<<<<
@@ -7374,25 +7524,27 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_12, &__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_11);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1317
+ /* "netCDF4/_netCDF4.pyx":1330
* # create a VLType instance from it.
* try:
* vltype = _read_vlen(group, xtype) # <<<<<<<<<<<<<<
* except KeyError:
* msg='WARNING: unsupported VLEN type, skipping...'
*/
- __pyx_t_10 = __pyx_f_7netCDF4_8_netCDF4__read_vlen(__pyx_v_group, __pyx_v_xtype, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1317; __pyx_clineno = __LINE__; goto __pyx_L31_error;}
+ __pyx_t_10 = __pyx_f_7netCDF4_8_netCDF4__read_vlen(__pyx_v_group, __pyx_v_xtype, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1330, __pyx_L31_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_XDECREF_SET(__pyx_v_vltype, __pyx_t_10);
__pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":1316
+ /* "netCDF4/_netCDF4.pyx":1329
* # read the VLEN type info from the file,
* # create a VLType instance from it.
* try: # <<<<<<<<<<<<<<
@@ -7405,6 +7557,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L38_try_end;
__pyx_L31_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -7413,22 +7566,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":1318
+ /* "netCDF4/_netCDF4.pyx":1331
* try:
* vltype = _read_vlen(group, xtype)
* except KeyError: # <<<<<<<<<<<<<<
* msg='WARNING: unsupported VLEN type, skipping...'
* warnings.warn(msg)
*/
- __pyx_t_14 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_14) {
__Pyx_AddTraceback("netCDF4._netCDF4._get_types", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_1, &__pyx_t_15) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1318; __pyx_clineno = __LINE__; goto __pyx_L33_except_error;}
+ if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_1, &__pyx_t_15) < 0) __PYX_ERR(0, 1331, __pyx_L33_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_15);
- /* "netCDF4/_netCDF4.pyx":1319
+ /* "netCDF4/_netCDF4.pyx":1332
* vltype = _read_vlen(group, xtype)
* except KeyError:
* msg='WARNING: unsupported VLEN type, skipping...' # <<<<<<<<<<<<<<
@@ -7438,16 +7591,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_INCREF(__pyx_kp_s_WARNING_unsupported_VLEN_type_sk);
__Pyx_XDECREF_SET(__pyx_v_msg, __pyx_kp_s_WARNING_unsupported_VLEN_type_sk);
- /* "netCDF4/_netCDF4.pyx":1320
+ /* "netCDF4/_netCDF4.pyx":1333
* except KeyError:
* msg='WARNING: unsupported VLEN type, skipping...'
* warnings.warn(msg) # <<<<<<<<<<<<<<
* continue
* vltypes[name] = vltype
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1320; __pyx_clineno = __LINE__; goto __pyx_L33_except_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1333, __pyx_L33_except_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1320; __pyx_clineno = __LINE__; goto __pyx_L33_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1333, __pyx_L33_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -7461,23 +7614,23 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
if (!__pyx_t_6) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_msg); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1320; __pyx_clineno = __LINE__; goto __pyx_L33_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_msg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1333, __pyx_L33_except_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1320; __pyx_clineno = __LINE__; goto __pyx_L33_except_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1333, __pyx_L33_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_msg);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1320; __pyx_clineno = __LINE__; goto __pyx_L33_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1333, __pyx_L33_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":1321
+ /* "netCDF4/_netCDF4.pyx":1334
* msg='WARNING: unsupported VLEN type, skipping...'
* warnings.warn(msg)
* continue # <<<<<<<<<<<<<<
@@ -7494,19 +7647,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
goto __pyx_L33_except_error;
__pyx_L33_except_error:;
- /* "netCDF4/_netCDF4.pyx":1316
+ /* "netCDF4/_netCDF4.pyx":1329
* # read the VLEN type info from the file,
* # create a VLType instance from it.
* try: # <<<<<<<<<<<<<<
* vltype = _read_vlen(group, xtype)
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_13, __pyx_t_12, __pyx_t_11);
goto __pyx_L1_error;
__pyx_L37_try_continue:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_11);
@@ -7515,16 +7670,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_L38_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1322
+ /* "netCDF4/_netCDF4.pyx":1335
* warnings.warn(msg)
* continue
* vltypes[name] = vltype # <<<<<<<<<<<<<<
* elif classp == NC_ENUM: # an enum type
* name = namstring.decode(default_encoding,unicode_error)
*/
- if (unlikely(PyObject_SetItem(__pyx_v_vltypes, __pyx_v_name, __pyx_v_vltype) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1322; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_vltypes, __pyx_v_name, __pyx_v_vltype) < 0)) __PYX_ERR(0, 1335, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1312
+ /* "netCDF4/_netCDF4.pyx":1325
* continue
* cmptypes[name] = cmptype
* elif classp == NC_VLEN: # a vlen # <<<<<<<<<<<<<<
@@ -7533,7 +7688,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
break;
- /* "netCDF4/_netCDF4.pyx":1323
+ /* "netCDF4/_netCDF4.pyx":1336
* continue
* vltypes[name] = vltype
* elif classp == NC_ENUM: # an enum type # <<<<<<<<<<<<<<
@@ -7542,21 +7697,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
case NC_ENUM:
- /* "netCDF4/_netCDF4.pyx":1324
+ /* "netCDF4/_netCDF4.pyx":1337
* vltypes[name] = vltype
* elif classp == NC_ENUM: # an enum type
* name = namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
* # read the Enum type info from the file,
* # create a EnumType instance from it.
*/
- __pyx_t_1 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1324; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_decode); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1324; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_decode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1324; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1324; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -7570,7 +7725,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_9 = 1;
}
}
- __pyx_t_5 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1324; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -7581,14 +7736,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_1 = 0;
__pyx_t_7 = 0;
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1324; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_15);
__pyx_t_15 = 0;
- /* "netCDF4/_netCDF4.pyx":1327
+ /* "netCDF4/_netCDF4.pyx":1340
* # read the Enum type info from the file,
* # create a EnumType instance from it.
* try: # <<<<<<<<<<<<<<
@@ -7596,25 +7751,27 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_13);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1328
+ /* "netCDF4/_netCDF4.pyx":1341
* # create a EnumType instance from it.
* try:
* enumtype = _read_enum(group, xtype) # <<<<<<<<<<<<<<
* except KeyError:
* msg='WARNING: unsupported Enum type, skipping...'
*/
- __pyx_t_15 = __pyx_f_7netCDF4_8_netCDF4__read_enum(__pyx_v_group, __pyx_v_xtype, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1328; __pyx_clineno = __LINE__; goto __pyx_L41_error;}
+ __pyx_t_15 = __pyx_f_7netCDF4_8_netCDF4__read_enum(__pyx_v_group, __pyx_v_xtype, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 1341, __pyx_L41_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_XDECREF_SET(__pyx_v_enumtype, __pyx_t_15);
__pyx_t_15 = 0;
- /* "netCDF4/_netCDF4.pyx":1327
+ /* "netCDF4/_netCDF4.pyx":1340
* # read the Enum type info from the file,
* # create a EnumType instance from it.
* try: # <<<<<<<<<<<<<<
@@ -7627,6 +7784,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
goto __pyx_L48_try_end;
__pyx_L41_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -7635,22 +7793,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
- /* "netCDF4/_netCDF4.pyx":1329
+ /* "netCDF4/_netCDF4.pyx":1342
* try:
* enumtype = _read_enum(group, xtype)
* except KeyError: # <<<<<<<<<<<<<<
* msg='WARNING: unsupported Enum type, skipping...'
* warnings.warn(msg)
*/
- __pyx_t_14 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_14 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_14) {
__Pyx_AddTraceback("netCDF4._netCDF4._get_types", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_10, &__pyx_t_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1329; __pyx_clineno = __LINE__; goto __pyx_L43_except_error;}
+ if (__Pyx_GetException(&__pyx_t_15, &__pyx_t_10, &__pyx_t_5) < 0) __PYX_ERR(0, 1342, __pyx_L43_except_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_t_5);
- /* "netCDF4/_netCDF4.pyx":1330
+ /* "netCDF4/_netCDF4.pyx":1343
* enumtype = _read_enum(group, xtype)
* except KeyError:
* msg='WARNING: unsupported Enum type, skipping...' # <<<<<<<<<<<<<<
@@ -7660,16 +7818,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__Pyx_INCREF(__pyx_kp_s_WARNING_unsupported_Enum_type_sk);
__Pyx_XDECREF_SET(__pyx_v_msg, __pyx_kp_s_WARNING_unsupported_Enum_type_sk);
- /* "netCDF4/_netCDF4.pyx":1331
+ /* "netCDF4/_netCDF4.pyx":1344
* except KeyError:
* msg='WARNING: unsupported Enum type, skipping...'
* warnings.warn(msg) # <<<<<<<<<<<<<<
* continue
* enumtypes[name] = enumtype
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1331; __pyx_clineno = __LINE__; goto __pyx_L43_except_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1344, __pyx_L43_except_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1331; __pyx_clineno = __LINE__; goto __pyx_L43_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_warn); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1344, __pyx_L43_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -7683,23 +7841,23 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
}
}
if (!__pyx_t_1) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_msg); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1331; __pyx_clineno = __LINE__; goto __pyx_L43_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_msg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1344, __pyx_L43_except_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1331; __pyx_clineno = __LINE__; goto __pyx_L43_except_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1344, __pyx_L43_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_msg);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1331; __pyx_clineno = __LINE__; goto __pyx_L43_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1344, __pyx_L43_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":1332
+ /* "netCDF4/_netCDF4.pyx":1345
* msg='WARNING: unsupported Enum type, skipping...'
* warnings.warn(msg)
* continue # <<<<<<<<<<<<<<
@@ -7716,19 +7874,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
goto __pyx_L43_except_error;
__pyx_L43_except_error:;
- /* "netCDF4/_netCDF4.pyx":1327
+ /* "netCDF4/_netCDF4.pyx":1340
* # read the Enum type info from the file,
* # create a EnumType instance from it.
* try: # <<<<<<<<<<<<<<
* enumtype = _read_enum(group, xtype)
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
goto __pyx_L1_error;
__pyx_L47_try_continue:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
@@ -7737,16 +7897,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_L48_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1333
+ /* "netCDF4/_netCDF4.pyx":1346
* warnings.warn(msg)
* continue
* enumtypes[name] = enumtype # <<<<<<<<<<<<<<
* free(typeids)
* return cmptypes, vltypes, enumtypes
*/
- if (unlikely(PyObject_SetItem(__pyx_v_enumtypes, __pyx_v_name, __pyx_v_enumtype) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1333; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_enumtypes, __pyx_v_name, __pyx_v_enumtype) < 0)) __PYX_ERR(0, 1346, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1323
+ /* "netCDF4/_netCDF4.pyx":1336
* continue
* vltypes[name] = vltype
* elif classp == NC_ENUM: # an enum type # <<<<<<<<<<<<<<
@@ -7759,7 +7919,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_L13_continue:;
}
- /* "netCDF4/_netCDF4.pyx":1334
+ /* "netCDF4/_netCDF4.pyx":1347
* continue
* enumtypes[name] = enumtype
* free(typeids) # <<<<<<<<<<<<<<
@@ -7768,7 +7928,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
free(__pyx_v_typeids);
- /* "netCDF4/_netCDF4.pyx":1293
+ /* "netCDF4/_netCDF4.pyx":1306
* vltypes = OrderedDict()
* enumtypes = OrderedDict()
* if ntypes > 0: # <<<<<<<<<<<<<<
@@ -7777,7 +7937,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
*/
}
- /* "netCDF4/_netCDF4.pyx":1335
+ /* "netCDF4/_netCDF4.pyx":1348
* enumtypes[name] = enumtype
* free(typeids)
* return cmptypes, vltypes, enumtypes # <<<<<<<<<<<<<<
@@ -7785,7 +7945,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
* cdef _get_dims(group):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1335; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1348, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_cmptypes);
__Pyx_GIVEREF(__pyx_v_cmptypes);
@@ -7800,7 +7960,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
__pyx_t_5 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1269
+ /* "netCDF4/_netCDF4.pyx":1282
* raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* cdef _get_types(group): # <<<<<<<<<<<<<<
@@ -7833,7 +7993,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_types(PyObject *__pyx_v_group)
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1337
+/* "netCDF4/_netCDF4.pyx":1350
* return cmptypes, vltypes, enumtypes
*
* cdef _get_dims(group): # <<<<<<<<<<<<<<
@@ -7862,25 +8022,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
PyObject *__pyx_t_8 = NULL;
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_dims", 0);
- /* "netCDF4/_netCDF4.pyx":1344
+ /* "netCDF4/_netCDF4.pyx":1357
* cdef char namstring[NC_MAX_NAME+1]
* # get number of dimensions in this Group.
* _grpid = group._grpid # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_ndims(_grpid, &numdims)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1357, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1357, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":1345
+ /* "netCDF4/_netCDF4.pyx":1358
* # get number of dimensions in this Group.
* _grpid = group._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -7894,7 +8051,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1346
+ /* "netCDF4/_netCDF4.pyx":1359
* _grpid = group._grpid
* with nogil:
* ierr = nc_inq_ndims(_grpid, &numdims) # <<<<<<<<<<<<<<
@@ -7904,7 +8061,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_ndims(__pyx_v__grpid, (&__pyx_v_numdims));
}
- /* "netCDF4/_netCDF4.pyx":1345
+ /* "netCDF4/_netCDF4.pyx":1358
* # get number of dimensions in this Group.
* _grpid = group._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -7922,7 +8079,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1347
+ /* "netCDF4/_netCDF4.pyx":1360
* with nogil:
* ierr = nc_inq_ndims(_grpid, &numdims)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -7932,7 +8089,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1348
+ /* "netCDF4/_netCDF4.pyx":1361
* ierr = nc_inq_ndims(_grpid, &numdims)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -7940,22 +8097,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
* dimensions = OrderedDict()
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1361, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1361, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1361, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1361, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1347
+ /* "netCDF4/_netCDF4.pyx":1360
* with nogil:
* ierr = nc_inq_ndims(_grpid, &numdims)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -7964,14 +8121,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1350
+ /* "netCDF4/_netCDF4.pyx":1363
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # create empty dictionary for dimensions.
* dimensions = OrderedDict() # <<<<<<<<<<<<<<
* if numdims > 0:
* dimids = <int *>malloc(sizeof(int) * numdims)
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1350; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
@@ -7984,17 +8141,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1350; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1363, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1350; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1363, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_dimensions = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1351
+ /* "netCDF4/_netCDF4.pyx":1364
* # create empty dictionary for dimensions.
* dimensions = OrderedDict()
* if numdims > 0: # <<<<<<<<<<<<<<
@@ -8004,7 +8161,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_numdims > 0) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1352
+ /* "netCDF4/_netCDF4.pyx":1365
* dimensions = OrderedDict()
* if numdims > 0:
* dimids = <int *>malloc(sizeof(int) * numdims) # <<<<<<<<<<<<<<
@@ -8013,20 +8170,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
*/
__pyx_v_dimids = ((int *)malloc(((sizeof(int)) * __pyx_v_numdims)));
- /* "netCDF4/_netCDF4.pyx":1353
+ /* "netCDF4/_netCDF4.pyx":1366
* if numdims > 0:
* dimids = <int *>malloc(sizeof(int) * numdims)
* if group.data_model == 'NETCDF4': # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_dimids(_grpid, &numdims, dimids, 0)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1353; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1366, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1353; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1366, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1354
+ /* "netCDF4/_netCDF4.pyx":1367
* dimids = <int *>malloc(sizeof(int) * numdims)
* if group.data_model == 'NETCDF4':
* with nogil: # <<<<<<<<<<<<<<
@@ -8040,7 +8197,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1355
+ /* "netCDF4/_netCDF4.pyx":1368
* if group.data_model == 'NETCDF4':
* with nogil:
* ierr = nc_inq_dimids(_grpid, &numdims, dimids, 0) # <<<<<<<<<<<<<<
@@ -8050,7 +8207,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_dimids(__pyx_v__grpid, (&__pyx_v_numdims), __pyx_v_dimids, 0);
}
- /* "netCDF4/_netCDF4.pyx":1354
+ /* "netCDF4/_netCDF4.pyx":1367
* dimids = <int *>malloc(sizeof(int) * numdims)
* if group.data_model == 'NETCDF4':
* with nogil: # <<<<<<<<<<<<<<
@@ -8068,7 +8225,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1356
+ /* "netCDF4/_netCDF4.pyx":1369
* with nogil:
* ierr = nc_inq_dimids(_grpid, &numdims, dimids, 0)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8078,7 +8235,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1357
+ /* "netCDF4/_netCDF4.pyx":1370
* ierr = nc_inq_dimids(_grpid, &numdims, dimids, 0)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -8086,22 +8243,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
* for n from 0 <= n < numdims:
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1370, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1356
+ /* "netCDF4/_netCDF4.pyx":1369
* with nogil:
* ierr = nc_inq_dimids(_grpid, &numdims, dimids, 0)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8110,7 +8267,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1353
+ /* "netCDF4/_netCDF4.pyx":1366
* if numdims > 0:
* dimids = <int *>malloc(sizeof(int) * numdims)
* if group.data_model == 'NETCDF4': # <<<<<<<<<<<<<<
@@ -8120,7 +8277,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
goto __pyx_L8;
}
- /* "netCDF4/_netCDF4.pyx":1359
+ /* "netCDF4/_netCDF4.pyx":1372
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* else:
* for n from 0 <= n < numdims: # <<<<<<<<<<<<<<
@@ -8131,7 +8288,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_t_2 = __pyx_v_numdims;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_2; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":1360
+ /* "netCDF4/_netCDF4.pyx":1373
* else:
* for n from 0 <= n < numdims:
* dimids[n] = n # <<<<<<<<<<<<<<
@@ -8143,7 +8300,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
}
__pyx_L8:;
- /* "netCDF4/_netCDF4.pyx":1361
+ /* "netCDF4/_netCDF4.pyx":1374
* for n from 0 <= n < numdims:
* dimids[n] = n
* for n from 0 <= n < numdims: # <<<<<<<<<<<<<<
@@ -8153,7 +8310,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_t_2 = __pyx_v_numdims;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_2; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":1362
+ /* "netCDF4/_netCDF4.pyx":1375
* dimids[n] = n
* for n from 0 <= n < numdims:
* with nogil: # <<<<<<<<<<<<<<
@@ -8167,7 +8324,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1363
+ /* "netCDF4/_netCDF4.pyx":1376
* for n from 0 <= n < numdims:
* with nogil:
* ierr = nc_inq_dimname(_grpid, dimids[n], namstring) # <<<<<<<<<<<<<<
@@ -8177,7 +8334,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_dimname(__pyx_v__grpid, (__pyx_v_dimids[__pyx_v_n]), __pyx_v_namstring);
}
- /* "netCDF4/_netCDF4.pyx":1362
+ /* "netCDF4/_netCDF4.pyx":1375
* dimids[n] = n
* for n from 0 <= n < numdims:
* with nogil: # <<<<<<<<<<<<<<
@@ -8195,7 +8352,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1364
+ /* "netCDF4/_netCDF4.pyx":1377
* with nogil:
* ierr = nc_inq_dimname(_grpid, dimids[n], namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8205,7 +8362,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1365
+ /* "netCDF4/_netCDF4.pyx":1378
* ierr = nc_inq_dimname(_grpid, dimids[n], namstring)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -8213,22 +8370,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
* dimensions[name] = Dimension(group, name, id=dimids[n])
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1378, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1364
+ /* "netCDF4/_netCDF4.pyx":1377
* with nogil:
* ierr = nc_inq_dimname(_grpid, dimids[n], namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8237,21 +8394,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1366
+ /* "netCDF4/_netCDF4.pyx":1379
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
* dimensions[name] = Dimension(group, name, id=dimids[n])
* free(dimids)
*/
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1366; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1366; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1366; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1366; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -8265,7 +8422,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1366; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -8276,21 +8433,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1366; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1367
+ /* "netCDF4/_netCDF4.pyx":1380
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error)
* dimensions[name] = Dimension(group, name, id=dimids[n]) # <<<<<<<<<<<<<<
* free(dimids)
* return dimensions
*/
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1367; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -8298,21 +8455,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_name);
- __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1367; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = __Pyx_PyInt_From_int((__pyx_v_dimids[__pyx_v_n])); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1367; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_From_int((__pyx_v_dimids[__pyx_v_n])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_id, __pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1367; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_id, __pyx_t_10) < 0) __PYX_ERR(0, 1380, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dimension), __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1367; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dimension), __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_dimensions, __pyx_v_name, __pyx_t_10) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1367; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_dimensions, __pyx_v_name, __pyx_t_10) < 0)) __PYX_ERR(0, 1380, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
- /* "netCDF4/_netCDF4.pyx":1368
+ /* "netCDF4/_netCDF4.pyx":1381
* name = namstring.decode(default_encoding,unicode_error)
* dimensions[name] = Dimension(group, name, id=dimids[n])
* free(dimids) # <<<<<<<<<<<<<<
@@ -8321,7 +8478,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
*/
free(__pyx_v_dimids);
- /* "netCDF4/_netCDF4.pyx":1351
+ /* "netCDF4/_netCDF4.pyx":1364
* # create empty dictionary for dimensions.
* dimensions = OrderedDict()
* if numdims > 0: # <<<<<<<<<<<<<<
@@ -8330,7 +8487,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1369
+ /* "netCDF4/_netCDF4.pyx":1382
* dimensions[name] = Dimension(group, name, id=dimids[n])
* free(dimids)
* return dimensions # <<<<<<<<<<<<<<
@@ -8342,7 +8499,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
__pyx_r = __pyx_v_dimensions;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1337
+ /* "netCDF4/_netCDF4.pyx":1350
* return cmptypes, vltypes, enumtypes
*
* cdef _get_dims(group): # <<<<<<<<<<<<<<
@@ -8368,7 +8525,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_dims(PyObject *__pyx_v_group) {
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1371
+/* "netCDF4/_netCDF4.pyx":1384
* return dimensions
*
* cdef _get_grps(group): # <<<<<<<<<<<<<<
@@ -8397,25 +8554,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
PyObject *__pyx_t_8 = NULL;
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_grps", 0);
- /* "netCDF4/_netCDF4.pyx":1378
+ /* "netCDF4/_netCDF4.pyx":1391
* cdef char namstring[NC_MAX_NAME+1]
* # get number of groups in this Group.
* _grpid = group._grpid # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_grps(_grpid, &numgrps, NULL)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1391, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1391, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":1379
+ /* "netCDF4/_netCDF4.pyx":1392
* # get number of groups in this Group.
* _grpid = group._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -8429,7 +8583,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1380
+ /* "netCDF4/_netCDF4.pyx":1393
* _grpid = group._grpid
* with nogil:
* ierr = nc_inq_grps(_grpid, &numgrps, NULL) # <<<<<<<<<<<<<<
@@ -8439,7 +8593,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_grps(__pyx_v__grpid, (&__pyx_v_numgrps), NULL);
}
- /* "netCDF4/_netCDF4.pyx":1379
+ /* "netCDF4/_netCDF4.pyx":1392
* # get number of groups in this Group.
* _grpid = group._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -8457,7 +8611,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1381
+ /* "netCDF4/_netCDF4.pyx":1394
* with nogil:
* ierr = nc_inq_grps(_grpid, &numgrps, NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8467,7 +8621,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1382
+ /* "netCDF4/_netCDF4.pyx":1395
* ierr = nc_inq_grps(_grpid, &numgrps, NULL)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -8475,22 +8629,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
* groups = OrderedDict()
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1382; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1395, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1382; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1395, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1382; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1395, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1382; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1395, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1381
+ /* "netCDF4/_netCDF4.pyx":1394
* with nogil:
* ierr = nc_inq_grps(_grpid, &numgrps, NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8499,14 +8653,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1384
+ /* "netCDF4/_netCDF4.pyx":1397
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # create dictionary containing `netCDF4.Group` instances for groups in this group
* groups = OrderedDict() # <<<<<<<<<<<<<<
* if numgrps > 0:
* grpids = <int *>malloc(sizeof(int) * numgrps)
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1397, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
@@ -8519,17 +8673,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1397, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1397, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_groups = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1385
+ /* "netCDF4/_netCDF4.pyx":1398
* # create dictionary containing `netCDF4.Group` instances for groups in this group
* groups = OrderedDict()
* if numgrps > 0: # <<<<<<<<<<<<<<
@@ -8539,7 +8693,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_numgrps > 0) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1386
+ /* "netCDF4/_netCDF4.pyx":1399
* groups = OrderedDict()
* if numgrps > 0:
* grpids = <int *>malloc(sizeof(int) * numgrps) # <<<<<<<<<<<<<<
@@ -8548,7 +8702,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
*/
__pyx_v_grpids = ((int *)malloc(((sizeof(int)) * __pyx_v_numgrps)));
- /* "netCDF4/_netCDF4.pyx":1387
+ /* "netCDF4/_netCDF4.pyx":1400
* if numgrps > 0:
* grpids = <int *>malloc(sizeof(int) * numgrps)
* with nogil: # <<<<<<<<<<<<<<
@@ -8562,7 +8716,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1388
+ /* "netCDF4/_netCDF4.pyx":1401
* grpids = <int *>malloc(sizeof(int) * numgrps)
* with nogil:
* ierr = nc_inq_grps(_grpid, NULL, grpids) # <<<<<<<<<<<<<<
@@ -8572,7 +8726,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_grps(__pyx_v__grpid, NULL, __pyx_v_grpids);
}
- /* "netCDF4/_netCDF4.pyx":1387
+ /* "netCDF4/_netCDF4.pyx":1400
* if numgrps > 0:
* grpids = <int *>malloc(sizeof(int) * numgrps)
* with nogil: # <<<<<<<<<<<<<<
@@ -8590,7 +8744,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1389
+ /* "netCDF4/_netCDF4.pyx":1402
* with nogil:
* ierr = nc_inq_grps(_grpid, NULL, grpids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8600,7 +8754,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1390
+ /* "netCDF4/_netCDF4.pyx":1403
* ierr = nc_inq_grps(_grpid, NULL, grpids)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -8608,22 +8762,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
* with nogil:
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1390; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1403, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1390; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1403, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1390; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1403, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1390; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1403, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1389
+ /* "netCDF4/_netCDF4.pyx":1402
* with nogil:
* ierr = nc_inq_grps(_grpid, NULL, grpids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8632,7 +8786,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1391
+ /* "netCDF4/_netCDF4.pyx":1404
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* for n from 0 <= n < numgrps: # <<<<<<<<<<<<<<
@@ -8642,7 +8796,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_t_2 = __pyx_v_numgrps;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_2; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":1392
+ /* "netCDF4/_netCDF4.pyx":1405
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* for n from 0 <= n < numgrps:
* with nogil: # <<<<<<<<<<<<<<
@@ -8656,7 +8810,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1393
+ /* "netCDF4/_netCDF4.pyx":1406
* for n from 0 <= n < numgrps:
* with nogil:
* ierr = nc_inq_grpname(grpids[n], namstring) # <<<<<<<<<<<<<<
@@ -8666,7 +8820,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_grpname((__pyx_v_grpids[__pyx_v_n]), __pyx_v_namstring);
}
- /* "netCDF4/_netCDF4.pyx":1392
+ /* "netCDF4/_netCDF4.pyx":1405
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* for n from 0 <= n < numgrps:
* with nogil: # <<<<<<<<<<<<<<
@@ -8684,7 +8838,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1394
+ /* "netCDF4/_netCDF4.pyx":1407
* with nogil:
* ierr = nc_inq_grpname(grpids[n], namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8694,7 +8848,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1395
+ /* "netCDF4/_netCDF4.pyx":1408
* ierr = nc_inq_grpname(grpids[n], namstring)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -8702,22 +8856,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
* groups[name] = Group(group, name, id=grpids[n])
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1395; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1408, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1395; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1408, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1395; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1408, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1395; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1408, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1394
+ /* "netCDF4/_netCDF4.pyx":1407
* with nogil:
* ierr = nc_inq_grpname(grpids[n], namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8726,21 +8880,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1396
+ /* "netCDF4/_netCDF4.pyx":1409
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
* groups[name] = Group(group, name, id=grpids[n])
* free(grpids)
*/
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -8754,7 +8908,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -8765,21 +8919,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1397
+ /* "netCDF4/_netCDF4.pyx":1410
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error)
* groups[name] = Group(group, name, id=grpids[n]) # <<<<<<<<<<<<<<
* free(grpids)
* return groups
*/
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1397; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1410, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -8787,21 +8941,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_name);
- __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1397; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1410, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = __Pyx_PyInt_From_int((__pyx_v_grpids[__pyx_v_n])); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1397; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_From_int((__pyx_v_grpids[__pyx_v_n])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1410, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_id, __pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1397; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_id, __pyx_t_10) < 0) __PYX_ERR(0, 1410, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Group), __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1397; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Group), __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1410, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_groups, __pyx_v_name, __pyx_t_10) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1397; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_groups, __pyx_v_name, __pyx_t_10) < 0)) __PYX_ERR(0, 1410, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
- /* "netCDF4/_netCDF4.pyx":1398
+ /* "netCDF4/_netCDF4.pyx":1411
* name = namstring.decode(default_encoding,unicode_error)
* groups[name] = Group(group, name, id=grpids[n])
* free(grpids) # <<<<<<<<<<<<<<
@@ -8810,7 +8964,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
*/
free(__pyx_v_grpids);
- /* "netCDF4/_netCDF4.pyx":1385
+ /* "netCDF4/_netCDF4.pyx":1398
* # create dictionary containing `netCDF4.Group` instances for groups in this group
* groups = OrderedDict()
* if numgrps > 0: # <<<<<<<<<<<<<<
@@ -8819,7 +8973,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1399
+ /* "netCDF4/_netCDF4.pyx":1412
* groups[name] = Group(group, name, id=grpids[n])
* free(grpids)
* return groups # <<<<<<<<<<<<<<
@@ -8831,7 +8985,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
__pyx_r = __pyx_v_groups;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1371
+ /* "netCDF4/_netCDF4.pyx":1384
* return dimensions
*
* cdef _get_grps(group): # <<<<<<<<<<<<<<
@@ -8857,7 +9011,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_grps(PyObject *__pyx_v_group) {
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1401
+/* "netCDF4/_netCDF4.pyx":1414
* return groups
*
* cdef _get_vars(group): # <<<<<<<<<<<<<<
@@ -8920,25 +9074,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
PyObject *(*__pyx_t_26)(PyObject *);
PyObject *(*__pyx_t_27)(PyObject *);
int __pyx_t_28;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get_vars", 0);
- /* "netCDF4/_netCDF4.pyx":1411
+ /* "netCDF4/_netCDF4.pyx":1424
* cdef char namstring_cmp[NC_MAX_NAME+1]
* # get number of variables in this Group.
* _grpid = group._grpid # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_nvars(_grpid, &numvars)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1424, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1424, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":1412
+ /* "netCDF4/_netCDF4.pyx":1425
* # get number of variables in this Group.
* _grpid = group._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -8952,7 +9103,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1413
+ /* "netCDF4/_netCDF4.pyx":1426
* _grpid = group._grpid
* with nogil:
* ierr = nc_inq_nvars(_grpid, &numvars) # <<<<<<<<<<<<<<
@@ -8962,7 +9113,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_nvars(__pyx_v__grpid, (&__pyx_v_numvars));
}
- /* "netCDF4/_netCDF4.pyx":1412
+ /* "netCDF4/_netCDF4.pyx":1425
* # get number of variables in this Group.
* _grpid = group._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -8980,7 +9131,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1414
+ /* "netCDF4/_netCDF4.pyx":1427
* with nogil:
* ierr = nc_inq_nvars(_grpid, &numvars)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -8990,7 +9141,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1415
+ /* "netCDF4/_netCDF4.pyx":1428
* ierr = nc_inq_nvars(_grpid, &numvars)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -8998,22 +9149,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* variables = OrderedDict()
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1415; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1428, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1415; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1428, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1415; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1428, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1415; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1428, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1414
+ /* "netCDF4/_netCDF4.pyx":1427
* with nogil:
* ierr = nc_inq_nvars(_grpid, &numvars)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9022,14 +9173,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1417
+ /* "netCDF4/_netCDF4.pyx":1430
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # create empty dictionary for variables.
* variables = OrderedDict() # <<<<<<<<<<<<<<
* if numvars > 0:
* # get variable ids.
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1417; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1430, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
@@ -9042,17 +9193,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1417; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1430, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1417; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1430, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_variables = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1418
+ /* "netCDF4/_netCDF4.pyx":1431
* # create empty dictionary for variables.
* variables = OrderedDict()
* if numvars > 0: # <<<<<<<<<<<<<<
@@ -9062,7 +9213,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_numvars > 0) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1420
+ /* "netCDF4/_netCDF4.pyx":1433
* if numvars > 0:
* # get variable ids.
* varids = <int *>malloc(sizeof(int) * numvars) # <<<<<<<<<<<<<<
@@ -9071,20 +9222,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
__pyx_v_varids = ((int *)malloc(((sizeof(int)) * __pyx_v_numvars)));
- /* "netCDF4/_netCDF4.pyx":1421
+ /* "netCDF4/_netCDF4.pyx":1434
* # get variable ids.
* varids = <int *>malloc(sizeof(int) * numvars)
* if group.data_model == 'NETCDF4': # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_varids(_grpid, &numvars, varids)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1421; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1434, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1421; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 1434, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1422
+ /* "netCDF4/_netCDF4.pyx":1435
* varids = <int *>malloc(sizeof(int) * numvars)
* if group.data_model == 'NETCDF4':
* with nogil: # <<<<<<<<<<<<<<
@@ -9098,7 +9249,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1423
+ /* "netCDF4/_netCDF4.pyx":1436
* if group.data_model == 'NETCDF4':
* with nogil:
* ierr = nc_inq_varids(_grpid, &numvars, varids) # <<<<<<<<<<<<<<
@@ -9108,7 +9259,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_varids(__pyx_v__grpid, (&__pyx_v_numvars), __pyx_v_varids);
}
- /* "netCDF4/_netCDF4.pyx":1422
+ /* "netCDF4/_netCDF4.pyx":1435
* varids = <int *>malloc(sizeof(int) * numvars)
* if group.data_model == 'NETCDF4':
* with nogil: # <<<<<<<<<<<<<<
@@ -9126,7 +9277,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1424
+ /* "netCDF4/_netCDF4.pyx":1437
* with nogil:
* ierr = nc_inq_varids(_grpid, &numvars, varids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9136,7 +9287,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1425
+ /* "netCDF4/_netCDF4.pyx":1438
* ierr = nc_inq_varids(_grpid, &numvars, varids)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -9144,22 +9295,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* for n from 0 <= n < numvars:
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1438, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1438, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1438, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1438, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1424
+ /* "netCDF4/_netCDF4.pyx":1437
* with nogil:
* ierr = nc_inq_varids(_grpid, &numvars, varids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9168,7 +9319,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1421
+ /* "netCDF4/_netCDF4.pyx":1434
* # get variable ids.
* varids = <int *>malloc(sizeof(int) * numvars)
* if group.data_model == 'NETCDF4': # <<<<<<<<<<<<<<
@@ -9178,7 +9329,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
goto __pyx_L8;
}
- /* "netCDF4/_netCDF4.pyx":1427
+ /* "netCDF4/_netCDF4.pyx":1440
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* else:
* for n from 0 <= n < numvars: # <<<<<<<<<<<<<<
@@ -9189,7 +9340,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_2 = __pyx_v_numvars;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_2; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":1428
+ /* "netCDF4/_netCDF4.pyx":1441
* else:
* for n from 0 <= n < numvars:
* varids[n] = n # <<<<<<<<<<<<<<
@@ -9201,7 +9352,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
__pyx_L8:;
- /* "netCDF4/_netCDF4.pyx":1430
+ /* "netCDF4/_netCDF4.pyx":1443
* varids[n] = n
* # loop over variables.
* for n from 0 <= n < numvars: # <<<<<<<<<<<<<<
@@ -9211,7 +9362,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_2 = __pyx_v_numvars;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_2; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":1431
+ /* "netCDF4/_netCDF4.pyx":1444
* # loop over variables.
* for n from 0 <= n < numvars:
* varid = varids[n] # <<<<<<<<<<<<<<
@@ -9220,7 +9371,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
__pyx_v_varid = (__pyx_v_varids[__pyx_v_n]);
- /* "netCDF4/_netCDF4.pyx":1433
+ /* "netCDF4/_netCDF4.pyx":1446
* varid = varids[n]
* # get variable name.
* with nogil: # <<<<<<<<<<<<<<
@@ -9234,7 +9385,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1434
+ /* "netCDF4/_netCDF4.pyx":1447
* # get variable name.
* with nogil:
* ierr = nc_inq_varname(_grpid, varid, namstring) # <<<<<<<<<<<<<<
@@ -9244,7 +9395,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_varname(__pyx_v__grpid, __pyx_v_varid, __pyx_v_namstring);
}
- /* "netCDF4/_netCDF4.pyx":1433
+ /* "netCDF4/_netCDF4.pyx":1446
* varid = varids[n]
* # get variable name.
* with nogil: # <<<<<<<<<<<<<<
@@ -9262,7 +9413,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1435
+ /* "netCDF4/_netCDF4.pyx":1448
* with nogil:
* ierr = nc_inq_varname(_grpid, varid, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9272,7 +9423,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1436
+ /* "netCDF4/_netCDF4.pyx":1449
* ierr = nc_inq_varname(_grpid, varid, namstring)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -9280,22 +9431,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* if ierr != NC_NOERR:
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1449, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1435
+ /* "netCDF4/_netCDF4.pyx":1448
* with nogil:
* ierr = nc_inq_varname(_grpid, varid, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9304,21 +9455,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1437
+ /* "netCDF4/_netCDF4.pyx":1450
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -9332,7 +9483,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -9343,14 +9494,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1438
+ /* "netCDF4/_netCDF4.pyx":1451
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9360,7 +9511,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1439
+ /* "netCDF4/_netCDF4.pyx":1452
* name = namstring.decode(default_encoding,unicode_error)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -9368,22 +9519,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* with nogil:
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1452, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1438
+ /* "netCDF4/_netCDF4.pyx":1451
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9392,7 +9543,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1441
+ /* "netCDF4/_netCDF4.pyx":1454
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # get variable type.
* with nogil: # <<<<<<<<<<<<<<
@@ -9406,7 +9557,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1442
+ /* "netCDF4/_netCDF4.pyx":1455
* # get variable type.
* with nogil:
* ierr = nc_inq_vartype(_grpid, varid, &xtype) # <<<<<<<<<<<<<<
@@ -9416,7 +9567,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_vartype(__pyx_v__grpid, __pyx_v_varid, (&__pyx_v_xtype));
}
- /* "netCDF4/_netCDF4.pyx":1441
+ /* "netCDF4/_netCDF4.pyx":1454
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # get variable type.
* with nogil: # <<<<<<<<<<<<<<
@@ -9434,7 +9585,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
- /* "netCDF4/_netCDF4.pyx":1443
+ /* "netCDF4/_netCDF4.pyx":1456
* with nogil:
* ierr = nc_inq_vartype(_grpid, varid, &xtype)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9444,7 +9595,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1444
+ /* "netCDF4/_netCDF4.pyx":1457
* ierr = nc_inq_vartype(_grpid, varid, &xtype)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -9452,22 +9603,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* endianness = None
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1444; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1457, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1444; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1457, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1444; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1457, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1444; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1457, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1443
+ /* "netCDF4/_netCDF4.pyx":1456
* with nogil:
* ierr = nc_inq_vartype(_grpid, varid, &xtype)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -9476,188 +9627,168 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1446
+ /* "netCDF4/_netCDF4.pyx":1459
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # get endian-ness of variable.
* endianness = None # <<<<<<<<<<<<<<
- * # assume data returned by HDF4 lib has already been byte-swapped
- * # (if needed) so that it is in native endian format (issue #391).
+ * with nogil:
+ * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
*/
__Pyx_INCREF(Py_None);
__Pyx_XDECREF_SET(__pyx_v_endianness, Py_None);
- /* "netCDF4/_netCDF4.pyx":1449
- * # assume data returned by HDF4 lib has already been byte-swapped
- * # (if needed) so that it is in native endian format (issue #391).
- * if group.disk_format != 'HDF4': # <<<<<<<<<<<<<<
- * with nogil:
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ /* "netCDF4/_netCDF4.pyx":1460
+ * # get endian-ness of variable.
+ * endianness = None
+ * with nogil: # <<<<<<<<<<<<<<
+ * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ * if ierr == NC_NOERR:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_disk_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_HDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (__pyx_t_3) {
+ {
+ #ifdef WITH_THREAD
+ PyThreadState *_save;
+ Py_UNBLOCK_THREADS
+ #endif
+ /*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1450
- * # (if needed) so that it is in native endian format (issue #391).
- * if group.disk_format != 'HDF4':
- * with nogil: # <<<<<<<<<<<<<<
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
- * if ierr == NC_NOERR:
+ /* "netCDF4/_netCDF4.pyx":1461
+ * endianness = None
+ * with nogil:
+ * ierr = nc_inq_var_endian(_grpid, varid, &iendian) # <<<<<<<<<<<<<<
+ * if ierr == NC_NOERR:
+ * if iendian == NC_ENDIAN_LITTLE:
*/
- {
- #ifdef WITH_THREAD
- PyThreadState *_save;
- Py_UNBLOCK_THREADS
- #endif
- /*try:*/ {
+ __pyx_v_ierr = nc_inq_var_endian(__pyx_v__grpid, __pyx_v_varid, (&__pyx_v_iendian));
+ }
- /* "netCDF4/_netCDF4.pyx":1451
- * if group.disk_format != 'HDF4':
- * with nogil:
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian) # <<<<<<<<<<<<<<
- * if ierr == NC_NOERR:
- * if iendian == NC_ENDIAN_LITTLE:
+ /* "netCDF4/_netCDF4.pyx":1460
+ * # get endian-ness of variable.
+ * endianness = None
+ * with nogil: # <<<<<<<<<<<<<<
+ * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ * if ierr == NC_NOERR:
*/
- __pyx_v_ierr = nc_inq_var_endian(__pyx_v__grpid, __pyx_v_varid, (&__pyx_v_iendian));
+ /*finally:*/ {
+ /*normal exit:*/{
+ #ifdef WITH_THREAD
+ Py_BLOCK_THREADS
+ #endif
+ goto __pyx_L34;
}
+ __pyx_L34:;
+ }
+ }
- /* "netCDF4/_netCDF4.pyx":1450
- * # (if needed) so that it is in native endian format (issue #391).
- * if group.disk_format != 'HDF4':
- * with nogil: # <<<<<<<<<<<<<<
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
- * if ierr == NC_NOERR:
+ /* "netCDF4/_netCDF4.pyx":1462
+ * with nogil:
+ * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ * if ierr == NC_NOERR: # <<<<<<<<<<<<<<
+ * if iendian == NC_ENDIAN_LITTLE:
+ * endianness = '<'
*/
- /*finally:*/ {
- /*normal exit:*/{
- #ifdef WITH_THREAD
- Py_BLOCK_THREADS
- #endif
- goto __pyx_L35;
- }
- __pyx_L35:;
- }
- }
+ __pyx_t_3 = ((__pyx_v_ierr == NC_NOERR) != 0);
+ if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":1452
- * with nogil:
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
- * if ierr == NC_NOERR: # <<<<<<<<<<<<<<
- * if iendian == NC_ENDIAN_LITTLE:
- * endianness = '<'
+ /* "netCDF4/_netCDF4.pyx":1463
+ * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ * if ierr == NC_NOERR:
+ * if iendian == NC_ENDIAN_LITTLE: # <<<<<<<<<<<<<<
+ * endianness = '<'
+ * elif iendian == NC_ENDIAN_BIG:
*/
- __pyx_t_3 = ((__pyx_v_ierr == NC_NOERR) != 0);
- if (__pyx_t_3) {
+ switch (__pyx_v_iendian) {
+ case NC_ENDIAN_LITTLE:
- /* "netCDF4/_netCDF4.pyx":1453
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
- * if ierr == NC_NOERR:
- * if iendian == NC_ENDIAN_LITTLE: # <<<<<<<<<<<<<<
- * endianness = '<'
- * elif iendian == NC_ENDIAN_BIG:
- */
- switch (__pyx_v_iendian) {
- case NC_ENDIAN_LITTLE:
-
- /* "netCDF4/_netCDF4.pyx":1454
- * if ierr == NC_NOERR:
- * if iendian == NC_ENDIAN_LITTLE:
- * endianness = '<' # <<<<<<<<<<<<<<
- * elif iendian == NC_ENDIAN_BIG:
- * endianness = '>'
- */
- __Pyx_INCREF(__pyx_kp_s__14);
- __Pyx_DECREF_SET(__pyx_v_endianness, __pyx_kp_s__14);
-
- /* "netCDF4/_netCDF4.pyx":1453
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
- * if ierr == NC_NOERR:
- * if iendian == NC_ENDIAN_LITTLE: # <<<<<<<<<<<<<<
- * endianness = '<'
- * elif iendian == NC_ENDIAN_BIG:
+ /* "netCDF4/_netCDF4.pyx":1464
+ * if ierr == NC_NOERR:
+ * if iendian == NC_ENDIAN_LITTLE:
+ * endianness = '<' # <<<<<<<<<<<<<<
+ * elif iendian == NC_ENDIAN_BIG:
+ * endianness = '>'
*/
- break;
+ __Pyx_INCREF(__pyx_kp_s__14);
+ __Pyx_DECREF_SET(__pyx_v_endianness, __pyx_kp_s__14);
- /* "netCDF4/_netCDF4.pyx":1455
- * if iendian == NC_ENDIAN_LITTLE:
- * endianness = '<'
- * elif iendian == NC_ENDIAN_BIG: # <<<<<<<<<<<<<<
- * endianness = '>'
- * # check to see if it is a supported user-defined type.
+ /* "netCDF4/_netCDF4.pyx":1463
+ * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ * if ierr == NC_NOERR:
+ * if iendian == NC_ENDIAN_LITTLE: # <<<<<<<<<<<<<<
+ * endianness = '<'
+ * elif iendian == NC_ENDIAN_BIG:
*/
- case NC_ENDIAN_BIG:
+ break;
- /* "netCDF4/_netCDF4.pyx":1456
- * endianness = '<'
- * elif iendian == NC_ENDIAN_BIG:
- * endianness = '>' # <<<<<<<<<<<<<<
+ /* "netCDF4/_netCDF4.pyx":1465
+ * if iendian == NC_ENDIAN_LITTLE:
+ * endianness = '<'
+ * elif iendian == NC_ENDIAN_BIG: # <<<<<<<<<<<<<<
+ * endianness = '>'
* # check to see if it is a supported user-defined type.
- * try:
*/
- __Pyx_INCREF(__pyx_kp_s__15);
- __Pyx_DECREF_SET(__pyx_v_endianness, __pyx_kp_s__15);
+ case NC_ENDIAN_BIG:
- /* "netCDF4/_netCDF4.pyx":1455
- * if iendian == NC_ENDIAN_LITTLE:
- * endianness = '<'
- * elif iendian == NC_ENDIAN_BIG: # <<<<<<<<<<<<<<
- * endianness = '>'
+ /* "netCDF4/_netCDF4.pyx":1466
+ * endianness = '<'
+ * elif iendian == NC_ENDIAN_BIG:
+ * endianness = '>' # <<<<<<<<<<<<<<
* # check to see if it is a supported user-defined type.
+ * try:
*/
- break;
- default: break;
- }
+ __Pyx_INCREF(__pyx_kp_s__15);
+ __Pyx_DECREF_SET(__pyx_v_endianness, __pyx_kp_s__15);
- /* "netCDF4/_netCDF4.pyx":1452
- * with nogil:
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
- * if ierr == NC_NOERR: # <<<<<<<<<<<<<<
- * if iendian == NC_ENDIAN_LITTLE:
- * endianness = '<'
+ /* "netCDF4/_netCDF4.pyx":1465
+ * if iendian == NC_ENDIAN_LITTLE:
+ * endianness = '<'
+ * elif iendian == NC_ENDIAN_BIG: # <<<<<<<<<<<<<<
+ * endianness = '>'
+ * # check to see if it is a supported user-defined type.
*/
+ break;
+ default: break;
}
- /* "netCDF4/_netCDF4.pyx":1449
- * # assume data returned by HDF4 lib has already been byte-swapped
- * # (if needed) so that it is in native endian format (issue #391).
- * if group.disk_format != 'HDF4': # <<<<<<<<<<<<<<
- * with nogil:
- * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ /* "netCDF4/_netCDF4.pyx":1462
+ * with nogil:
+ * ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ * if ierr == NC_NOERR: # <<<<<<<<<<<<<<
+ * if iendian == NC_ENDIAN_LITTLE:
+ * endianness = '<'
*/
}
- /* "netCDF4/_netCDF4.pyx":1458
- * endianness = '>'
+ /* "netCDF4/_netCDF4.pyx":1468
+ * endianness = '>'
* # check to see if it is a supported user-defined type.
* try: # <<<<<<<<<<<<<<
* datatype = _nctonptype[xtype]
* if endianness is not None:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_13);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1459
+ /* "netCDF4/_netCDF4.pyx":1469
* # check to see if it is a supported user-defined type.
* try:
* datatype = _nctonptype[xtype] # <<<<<<<<<<<<<<
* if endianness is not None:
* datatype = endianness + datatype
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; __pyx_clineno = __LINE__; goto __pyx_L37_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1469, __pyx_L36_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_xtype, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1459; __pyx_clineno = __LINE__; goto __pyx_L37_error;};
+ __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_xtype, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1469, __pyx_L36_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_datatype, __pyx_t_6);
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1460
+ /* "netCDF4/_netCDF4.pyx":1470
* try:
* datatype = _nctonptype[xtype]
* if endianness is not None: # <<<<<<<<<<<<<<
@@ -9668,19 +9799,19 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_14 = (__pyx_t_3 != 0);
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":1461
+ /* "netCDF4/_netCDF4.pyx":1471
* datatype = _nctonptype[xtype]
* if endianness is not None:
* datatype = endianness + datatype # <<<<<<<<<<<<<<
* except KeyError:
* if xtype == NC_STRING:
*/
- __pyx_t_6 = PyNumber_Add(__pyx_v_endianness, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1461; __pyx_clineno = __LINE__; goto __pyx_L37_error;}
+ __pyx_t_6 = PyNumber_Add(__pyx_v_endianness, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1471, __pyx_L36_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF_SET(__pyx_v_datatype, __pyx_t_6);
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1460
+ /* "netCDF4/_netCDF4.pyx":1470
* try:
* datatype = _nctonptype[xtype]
* if endianness is not None: # <<<<<<<<<<<<<<
@@ -9689,8 +9820,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1458
- * endianness = '>'
+ /* "netCDF4/_netCDF4.pyx":1468
+ * endianness = '>'
* # check to see if it is a supported user-defined type.
* try: # <<<<<<<<<<<<<<
* datatype = _nctonptype[xtype]
@@ -9700,8 +9831,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
- goto __pyx_L44_try_end;
- __pyx_L37_error:;
+ goto __pyx_L43_try_end;
+ __pyx_L36_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -9709,22 +9841,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1462
+ /* "netCDF4/_netCDF4.pyx":1472
* if endianness is not None:
* datatype = endianness + datatype
* except KeyError: # <<<<<<<<<<<<<<
* if xtype == NC_STRING:
* datatype = str
*/
- __pyx_t_15 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_15 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_15) {
__Pyx_AddTraceback("netCDF4._netCDF4._get_vars", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_1, &__pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1462; __pyx_clineno = __LINE__; goto __pyx_L39_except_error;}
+ if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_1, &__pyx_t_10) < 0) __PYX_ERR(0, 1472, __pyx_L38_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_10);
- /* "netCDF4/_netCDF4.pyx":1463
+ /* "netCDF4/_netCDF4.pyx":1473
* datatype = endianness + datatype
* except KeyError:
* if xtype == NC_STRING: # <<<<<<<<<<<<<<
@@ -9734,7 +9866,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_14 = ((__pyx_v_xtype == NC_STRING) != 0);
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":1464
+ /* "netCDF4/_netCDF4.pyx":1474
* except KeyError:
* if xtype == NC_STRING:
* datatype = str # <<<<<<<<<<<<<<
@@ -9744,17 +9876,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_INCREF(((PyObject *)(&PyString_Type)));
__Pyx_XDECREF_SET(__pyx_v_datatype, ((PyObject *)(&PyString_Type)));
- /* "netCDF4/_netCDF4.pyx":1463
+ /* "netCDF4/_netCDF4.pyx":1473
* datatype = endianness + datatype
* except KeyError:
* if xtype == NC_STRING: # <<<<<<<<<<<<<<
* datatype = str
* else:
*/
- goto __pyx_L48;
+ goto __pyx_L47;
}
- /* "netCDF4/_netCDF4.pyx":1466
+ /* "netCDF4/_netCDF4.pyx":1476
* datatype = str
* else:
* with nogil: # <<<<<<<<<<<<<<
@@ -9769,7 +9901,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1467
+ /* "netCDF4/_netCDF4.pyx":1477
* else:
* with nogil:
* ierr = nc_inq_user_type(_grpid, xtype, namstring_cmp, # <<<<<<<<<<<<<<
@@ -9779,7 +9911,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_user_type(__pyx_v__grpid, __pyx_v_xtype, __pyx_v_namstring_cmp, NULL, NULL, NULL, (&__pyx_v_classp));
}
- /* "netCDF4/_netCDF4.pyx":1466
+ /* "netCDF4/_netCDF4.pyx":1476
* datatype = str
* else:
* with nogil: # <<<<<<<<<<<<<<
@@ -9791,13 +9923,13 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#ifdef WITH_THREAD
Py_BLOCK_THREADS
#endif
- goto __pyx_L53;
+ goto __pyx_L52;
}
- __pyx_L53:;
+ __pyx_L52:;
}
}
- /* "netCDF4/_netCDF4.pyx":1469
+ /* "netCDF4/_netCDF4.pyx":1479
* ierr = nc_inq_user_type(_grpid, xtype, namstring_cmp,
* NULL, NULL, NULL, &classp)
* if classp == NC_COMPOUND: # a compound type # <<<<<<<<<<<<<<
@@ -9807,7 +9939,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
switch (__pyx_v_classp) {
case NC_COMPOUND:
- /* "netCDF4/_netCDF4.pyx":1471
+ /* "netCDF4/_netCDF4.pyx":1481
* if classp == NC_COMPOUND: # a compound type
* # create CompoundType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
@@ -9815,13 +9947,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1472
+ /* "netCDF4/_netCDF4.pyx":1482
* # create CompoundType instance describing this compound type.
* try:
* datatype = _read_compound(group, xtype, endian=endianness) # <<<<<<<<<<<<<<
@@ -9830,12 +9964,12 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
__pyx_t_19.__pyx_n = 1;
__pyx_t_19.endian = __pyx_v_endianness;
- __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__read_compound(__pyx_v_group, __pyx_v_xtype, &__pyx_t_19); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1472; __pyx_clineno = __LINE__; goto __pyx_L54_error;}
+ __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__read_compound(__pyx_v_group, __pyx_v_xtype, &__pyx_t_19); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1482, __pyx_L53_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_XDECREF_SET(__pyx_v_datatype, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":1471
+ /* "netCDF4/_netCDF4.pyx":1481
* if classp == NC_COMPOUND: # a compound type
* # create CompoundType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
@@ -9846,49 +9980,50 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
- goto __pyx_L61_try_end;
- __pyx_L54_error:;
+ goto __pyx_L60_try_end;
+ __pyx_L53_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":1473
+ /* "netCDF4/_netCDF4.pyx":1483
* try:
* datatype = _read_compound(group, xtype, endian=endianness)
* except KeyError: # <<<<<<<<<<<<<<
* msg="WARNING: variable '%s' has unsupported compound datatype, skipping .." % name
* warnings.warn(msg)
*/
- __pyx_t_15 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_15 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_15) {
__Pyx_AddTraceback("netCDF4._netCDF4._get_vars", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1473; __pyx_clineno = __LINE__; goto __pyx_L56_except_error;}
+ if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_8) < 0) __PYX_ERR(0, 1483, __pyx_L55_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_8);
- /* "netCDF4/_netCDF4.pyx":1474
+ /* "netCDF4/_netCDF4.pyx":1484
* datatype = _read_compound(group, xtype, endian=endianness)
* except KeyError:
* msg="WARNING: variable '%s' has unsupported compound datatype, skipping .." % name # <<<<<<<<<<<<<<
* warnings.warn(msg)
* continue
*/
- __pyx_t_20 = __Pyx_PyString_Format(__pyx_kp_s_WARNING_variable_s_has_unsupport, __pyx_v_name); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1474; __pyx_clineno = __LINE__; goto __pyx_L56_except_error;}
+ __pyx_t_20 = __Pyx_PyString_Format(__pyx_kp_s_WARNING_variable_s_has_unsupport, __pyx_v_name); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1484, __pyx_L55_except_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_XDECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_20));
__pyx_t_20 = 0;
- /* "netCDF4/_netCDF4.pyx":1475
+ /* "netCDF4/_netCDF4.pyx":1485
* except KeyError:
* msg="WARNING: variable '%s' has unsupported compound datatype, skipping .." % name
* warnings.warn(msg) # <<<<<<<<<<<<<<
* continue
* elif classp == NC_VLEN: # a compound type
*/
- __pyx_t_21 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; __pyx_clineno = __LINE__; goto __pyx_L56_except_error;}
+ __pyx_t_21 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 1485, __pyx_L55_except_error)
__Pyx_GOTREF(__pyx_t_21);
- __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_n_s_warn); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; __pyx_clineno = __LINE__; goto __pyx_L56_except_error;}
+ __pyx_t_22 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_n_s_warn); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1485, __pyx_L55_except_error)
__Pyx_GOTREF(__pyx_t_22);
__Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
__pyx_t_21 = NULL;
@@ -9902,61 +10037,63 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
if (!__pyx_t_21) {
- __pyx_t_20 = __Pyx_PyObject_CallOneArg(__pyx_t_22, __pyx_v_msg); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; __pyx_clineno = __LINE__; goto __pyx_L56_except_error;}
+ __pyx_t_20 = __Pyx_PyObject_CallOneArg(__pyx_t_22, __pyx_v_msg); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1485, __pyx_L55_except_error)
__Pyx_GOTREF(__pyx_t_20);
} else {
- __pyx_t_23 = PyTuple_New(1+1); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; __pyx_clineno = __LINE__; goto __pyx_L56_except_error;}
+ __pyx_t_23 = PyTuple_New(1+1); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1485, __pyx_L55_except_error)
__Pyx_GOTREF(__pyx_t_23);
__Pyx_GIVEREF(__pyx_t_21); PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_t_21); __pyx_t_21 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_23, 0+1, __pyx_v_msg);
- __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_22, __pyx_t_23, NULL); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1475; __pyx_clineno = __LINE__; goto __pyx_L56_except_error;}
+ __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_22, __pyx_t_23, NULL); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1485, __pyx_L55_except_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
}
__Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
__Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
- /* "netCDF4/_netCDF4.pyx":1476
+ /* "netCDF4/_netCDF4.pyx":1486
* msg="WARNING: variable '%s' has unsupported compound datatype, skipping .." % name
* warnings.warn(msg)
* continue # <<<<<<<<<<<<<<
* elif classp == NC_VLEN: # a compound type
* # create VLType instance describing this compound type.
*/
- goto __pyx_L63_except_continue;
- __pyx_L63_except_continue:;
+ goto __pyx_L62_except_continue;
+ __pyx_L62_except_continue:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- goto __pyx_L60_try_continue;
+ goto __pyx_L59_try_continue;
}
- goto __pyx_L56_except_error;
- __pyx_L56_except_error:;
+ goto __pyx_L55_except_error;
+ __pyx_L55_except_error:;
- /* "netCDF4/_netCDF4.pyx":1471
+ /* "netCDF4/_netCDF4.pyx":1481
* if classp == NC_COMPOUND: # a compound type
* # create CompoundType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
* datatype = _read_compound(group, xtype, endian=endianness)
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
- goto __pyx_L39_except_error;
- __pyx_L60_try_continue:;
+ goto __pyx_L38_except_error;
+ __pyx_L59_try_continue:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
- goto __pyx_L47_except_continue;
- __pyx_L61_try_end:;
+ goto __pyx_L46_except_continue;
+ __pyx_L60_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1469
+ /* "netCDF4/_netCDF4.pyx":1479
* ierr = nc_inq_user_type(_grpid, xtype, namstring_cmp,
* NULL, NULL, NULL, &classp)
* if classp == NC_COMPOUND: # a compound type # <<<<<<<<<<<<<<
@@ -9965,7 +10102,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
break;
- /* "netCDF4/_netCDF4.pyx":1477
+ /* "netCDF4/_netCDF4.pyx":1487
* warnings.warn(msg)
* continue
* elif classp == NC_VLEN: # a compound type # <<<<<<<<<<<<<<
@@ -9974,7 +10111,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
case NC_VLEN:
- /* "netCDF4/_netCDF4.pyx":1479
+ /* "netCDF4/_netCDF4.pyx":1489
* elif classp == NC_VLEN: # a compound type
* # create VLType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
@@ -9982,13 +10119,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_18, &__pyx_t_17, &__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_16);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1480
+ /* "netCDF4/_netCDF4.pyx":1490
* # create VLType instance describing this compound type.
* try:
* datatype = _read_vlen(group, xtype, endian=endianness) # <<<<<<<<<<<<<<
@@ -9997,12 +10136,12 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
__pyx_t_24.__pyx_n = 1;
__pyx_t_24.endian = __pyx_v_endianness;
- __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__read_vlen(__pyx_v_group, __pyx_v_xtype, &__pyx_t_24); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1480; __pyx_clineno = __LINE__; goto __pyx_L64_error;}
+ __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__read_vlen(__pyx_v_group, __pyx_v_xtype, &__pyx_t_24); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1490, __pyx_L63_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_XDECREF_SET(__pyx_v_datatype, __pyx_t_8);
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1479
+ /* "netCDF4/_netCDF4.pyx":1489
* elif classp == NC_VLEN: # a compound type
* # create VLType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
@@ -10013,8 +10152,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
- goto __pyx_L71_try_end;
- __pyx_L64_error:;
+ goto __pyx_L70_try_end;
+ __pyx_L63_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
__Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
__Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
@@ -10023,43 +10163,43 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1481
+ /* "netCDF4/_netCDF4.pyx":1491
* try:
* datatype = _read_vlen(group, xtype, endian=endianness)
* except KeyError: # <<<<<<<<<<<<<<
* msg="WARNING: variable '%s' has unsupported VLEN datatype, skipping .." % name
* warnings.warn(msg)
*/
- __pyx_t_15 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_15 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_15) {
__Pyx_AddTraceback("netCDF4._netCDF4._get_vars", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_5, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1481; __pyx_clineno = __LINE__; goto __pyx_L66_except_error;}
+ if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_5, &__pyx_t_7) < 0) __PYX_ERR(0, 1491, __pyx_L65_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_7);
- /* "netCDF4/_netCDF4.pyx":1482
+ /* "netCDF4/_netCDF4.pyx":1492
* datatype = _read_vlen(group, xtype, endian=endianness)
* except KeyError:
* msg="WARNING: variable '%s' has unsupported VLEN datatype, skipping .." % name # <<<<<<<<<<<<<<
* warnings.warn(msg)
* continue
*/
- __pyx_t_20 = __Pyx_PyString_Format(__pyx_kp_s_WARNING_variable_s_has_unsupport_2, __pyx_v_name); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1482; __pyx_clineno = __LINE__; goto __pyx_L66_except_error;}
+ __pyx_t_20 = __Pyx_PyString_Format(__pyx_kp_s_WARNING_variable_s_has_unsupport_2, __pyx_v_name); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1492, __pyx_L65_except_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_XDECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_20));
__pyx_t_20 = 0;
- /* "netCDF4/_netCDF4.pyx":1483
+ /* "netCDF4/_netCDF4.pyx":1493
* except KeyError:
* msg="WARNING: variable '%s' has unsupported VLEN datatype, skipping .." % name
* warnings.warn(msg) # <<<<<<<<<<<<<<
* continue
* elif classp == NC_ENUM:
*/
- __pyx_t_22 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; __pyx_clineno = __LINE__; goto __pyx_L66_except_error;}
+ __pyx_t_22 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1493, __pyx_L65_except_error)
__Pyx_GOTREF(__pyx_t_22);
- __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_n_s_warn); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; __pyx_clineno = __LINE__; goto __pyx_L66_except_error;}
+ __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_n_s_warn); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1493, __pyx_L65_except_error)
__Pyx_GOTREF(__pyx_t_23);
__Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
__pyx_t_22 = NULL;
@@ -10073,61 +10213,63 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
if (!__pyx_t_22) {
- __pyx_t_20 = __Pyx_PyObject_CallOneArg(__pyx_t_23, __pyx_v_msg); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; __pyx_clineno = __LINE__; goto __pyx_L66_except_error;}
+ __pyx_t_20 = __Pyx_PyObject_CallOneArg(__pyx_t_23, __pyx_v_msg); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1493, __pyx_L65_except_error)
__Pyx_GOTREF(__pyx_t_20);
} else {
- __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; __pyx_clineno = __LINE__; goto __pyx_L66_except_error;}
+ __pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 1493, __pyx_L65_except_error)
__Pyx_GOTREF(__pyx_t_21);
__Pyx_GIVEREF(__pyx_t_22); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_22); __pyx_t_22 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_v_msg);
- __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_23, __pyx_t_21, NULL); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1483; __pyx_clineno = __LINE__; goto __pyx_L66_except_error;}
+ __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_23, __pyx_t_21, NULL); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1493, __pyx_L65_except_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
}
__Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
__Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
- /* "netCDF4/_netCDF4.pyx":1484
+ /* "netCDF4/_netCDF4.pyx":1494
* msg="WARNING: variable '%s' has unsupported VLEN datatype, skipping .." % name
* warnings.warn(msg)
* continue # <<<<<<<<<<<<<<
* elif classp == NC_ENUM:
* # create EnumType instance describing this compound type.
*/
- goto __pyx_L73_except_continue;
- __pyx_L73_except_continue:;
+ goto __pyx_L72_except_continue;
+ __pyx_L72_except_continue:;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- goto __pyx_L70_try_continue;
+ goto __pyx_L69_try_continue;
}
- goto __pyx_L66_except_error;
- __pyx_L66_except_error:;
+ goto __pyx_L65_except_error;
+ __pyx_L65_except_error:;
- /* "netCDF4/_netCDF4.pyx":1479
+ /* "netCDF4/_netCDF4.pyx":1489
* elif classp == NC_VLEN: # a compound type
* # create VLType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
* datatype = _read_vlen(group, xtype, endian=endianness)
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_ExceptionReset(__pyx_t_18, __pyx_t_17, __pyx_t_16);
- goto __pyx_L39_except_error;
- __pyx_L70_try_continue:;
+ goto __pyx_L38_except_error;
+ __pyx_L69_try_continue:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_ExceptionReset(__pyx_t_18, __pyx_t_17, __pyx_t_16);
- goto __pyx_L47_except_continue;
- __pyx_L71_try_end:;
+ goto __pyx_L46_except_continue;
+ __pyx_L70_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1477
+ /* "netCDF4/_netCDF4.pyx":1487
* warnings.warn(msg)
* continue
* elif classp == NC_VLEN: # a compound type # <<<<<<<<<<<<<<
@@ -10136,7 +10278,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
break;
- /* "netCDF4/_netCDF4.pyx":1485
+ /* "netCDF4/_netCDF4.pyx":1495
* warnings.warn(msg)
* continue
* elif classp == NC_ENUM: # <<<<<<<<<<<<<<
@@ -10145,7 +10287,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
case NC_ENUM:
- /* "netCDF4/_netCDF4.pyx":1487
+ /* "netCDF4/_netCDF4.pyx":1497
* elif classp == NC_ENUM:
* # create EnumType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
@@ -10153,13 +10295,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1488
+ /* "netCDF4/_netCDF4.pyx":1498
* # create EnumType instance describing this compound type.
* try:
* datatype = _read_enum(group, xtype, endian=endianness) # <<<<<<<<<<<<<<
@@ -10168,12 +10312,12 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
__pyx_t_25.__pyx_n = 1;
__pyx_t_25.endian = __pyx_v_endianness;
- __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__read_enum(__pyx_v_group, __pyx_v_xtype, &__pyx_t_25); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1488; __pyx_clineno = __LINE__; goto __pyx_L74_error;}
+ __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__read_enum(__pyx_v_group, __pyx_v_xtype, &__pyx_t_25); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1498, __pyx_L73_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_XDECREF_SET(__pyx_v_datatype, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":1487
+ /* "netCDF4/_netCDF4.pyx":1497
* elif classp == NC_ENUM:
* # create EnumType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
@@ -10184,8 +10328,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
- goto __pyx_L81_try_end;
- __pyx_L74_error:;
+ goto __pyx_L80_try_end;
+ __pyx_L73_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0;
__Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
__Pyx_XDECREF(__pyx_t_23); __pyx_t_23 = 0;
@@ -10194,43 +10339,43 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":1489
+ /* "netCDF4/_netCDF4.pyx":1499
* try:
* datatype = _read_enum(group, xtype, endian=endianness)
* except KeyError: # <<<<<<<<<<<<<<
* msg="WARNING: variable '%s' has unsupported Enum datatype, skipping .." % name
* warnings.warn(msg)
*/
- __pyx_t_15 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_15 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_15) {
__Pyx_AddTraceback("netCDF4._netCDF4._get_vars", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1489; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;}
+ if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_5, &__pyx_t_8) < 0) __PYX_ERR(0, 1499, __pyx_L75_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_8);
- /* "netCDF4/_netCDF4.pyx":1490
+ /* "netCDF4/_netCDF4.pyx":1500
* datatype = _read_enum(group, xtype, endian=endianness)
* except KeyError:
* msg="WARNING: variable '%s' has unsupported Enum datatype, skipping .." % name # <<<<<<<<<<<<<<
* warnings.warn(msg)
* continue
*/
- __pyx_t_20 = __Pyx_PyString_Format(__pyx_kp_s_WARNING_variable_s_has_unsupport_3, __pyx_v_name); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1490; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;}
+ __pyx_t_20 = __Pyx_PyString_Format(__pyx_kp_s_WARNING_variable_s_has_unsupport_3, __pyx_v_name); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1500, __pyx_L75_except_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_XDECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_20));
__pyx_t_20 = 0;
- /* "netCDF4/_netCDF4.pyx":1491
+ /* "netCDF4/_netCDF4.pyx":1501
* except KeyError:
* msg="WARNING: variable '%s' has unsupported Enum datatype, skipping .." % name
* warnings.warn(msg) # <<<<<<<<<<<<<<
* continue
* else:
*/
- __pyx_t_23 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1491; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;}
+ __pyx_t_23 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1501, __pyx_L75_except_error)
__Pyx_GOTREF(__pyx_t_23);
- __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_n_s_warn); if (unlikely(!__pyx_t_21)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1491; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;}
+ __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_n_s_warn); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 1501, __pyx_L75_except_error)
__Pyx_GOTREF(__pyx_t_21);
__Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
__pyx_t_23 = NULL;
@@ -10244,61 +10389,63 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
if (!__pyx_t_23) {
- __pyx_t_20 = __Pyx_PyObject_CallOneArg(__pyx_t_21, __pyx_v_msg); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1491; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;}
+ __pyx_t_20 = __Pyx_PyObject_CallOneArg(__pyx_t_21, __pyx_v_msg); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1501, __pyx_L75_except_error)
__Pyx_GOTREF(__pyx_t_20);
} else {
- __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1491; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;}
+ __pyx_t_22 = PyTuple_New(1+1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1501, __pyx_L75_except_error)
__Pyx_GOTREF(__pyx_t_22);
__Pyx_GIVEREF(__pyx_t_23); PyTuple_SET_ITEM(__pyx_t_22, 0, __pyx_t_23); __pyx_t_23 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_22, 0+1, __pyx_v_msg);
- __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_21, __pyx_t_22, NULL); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1491; __pyx_clineno = __LINE__; goto __pyx_L76_except_error;}
+ __pyx_t_20 = __Pyx_PyObject_Call(__pyx_t_21, __pyx_t_22, NULL); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1501, __pyx_L75_except_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0;
}
__Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
__Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
- /* "netCDF4/_netCDF4.pyx":1492
+ /* "netCDF4/_netCDF4.pyx":1502
* msg="WARNING: variable '%s' has unsupported Enum datatype, skipping .." % name
* warnings.warn(msg)
* continue # <<<<<<<<<<<<<<
* else:
* msg="WARNING: variable '%s' has unsupported datatype, skipping .." % name
*/
- goto __pyx_L83_except_continue;
- __pyx_L83_except_continue:;
+ goto __pyx_L82_except_continue;
+ __pyx_L82_except_continue:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- goto __pyx_L80_try_continue;
+ goto __pyx_L79_try_continue;
}
- goto __pyx_L76_except_error;
- __pyx_L76_except_error:;
+ goto __pyx_L75_except_error;
+ __pyx_L75_except_error:;
- /* "netCDF4/_netCDF4.pyx":1487
+ /* "netCDF4/_netCDF4.pyx":1497
* elif classp == NC_ENUM:
* # create EnumType instance describing this compound type.
* try: # <<<<<<<<<<<<<<
* datatype = _read_enum(group, xtype, endian=endianness)
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
- goto __pyx_L39_except_error;
- __pyx_L80_try_continue:;
+ goto __pyx_L38_except_error;
+ __pyx_L79_try_continue:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
- goto __pyx_L47_except_continue;
- __pyx_L81_try_end:;
+ goto __pyx_L46_except_continue;
+ __pyx_L80_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1485
+ /* "netCDF4/_netCDF4.pyx":1495
* warnings.warn(msg)
* continue
* elif classp == NC_ENUM: # <<<<<<<<<<<<<<
@@ -10308,28 +10455,28 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
break;
default:
- /* "netCDF4/_netCDF4.pyx":1494
+ /* "netCDF4/_netCDF4.pyx":1504
* continue
* else:
* msg="WARNING: variable '%s' has unsupported datatype, skipping .." % name # <<<<<<<<<<<<<<
* warnings.warn(msg)
* continue
*/
- __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_WARNING_variable_s_has_unsupport_4, __pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1494; __pyx_clineno = __LINE__; goto __pyx_L39_except_error;}
+ __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_WARNING_variable_s_has_unsupport_4, __pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1504, __pyx_L38_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_XDECREF_SET(__pyx_v_msg, ((PyObject*)__pyx_t_8));
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1495
+ /* "netCDF4/_netCDF4.pyx":1505
* else:
* msg="WARNING: variable '%s' has unsupported datatype, skipping .." % name
* warnings.warn(msg) # <<<<<<<<<<<<<<
* continue
* # get number of dimensions.
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1495; __pyx_clineno = __LINE__; goto __pyx_L39_except_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1505, __pyx_L38_except_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_warn); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1495; __pyx_clineno = __LINE__; goto __pyx_L39_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_warn); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1505, __pyx_L38_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = NULL;
@@ -10343,74 +10490,77 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
if (!__pyx_t_5) {
- __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_msg); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1495; __pyx_clineno = __LINE__; goto __pyx_L39_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_msg); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1505, __pyx_L38_except_error)
__Pyx_GOTREF(__pyx_t_8);
} else {
- __pyx_t_20 = PyTuple_New(1+1); if (unlikely(!__pyx_t_20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1495; __pyx_clineno = __LINE__; goto __pyx_L39_except_error;}
+ __pyx_t_20 = PyTuple_New(1+1); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 1505, __pyx_L38_except_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_20, 0+1, __pyx_v_msg);
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_20, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1495; __pyx_clineno = __LINE__; goto __pyx_L39_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_20, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1505, __pyx_L38_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1496
+ /* "netCDF4/_netCDF4.pyx":1506
* msg="WARNING: variable '%s' has unsupported datatype, skipping .." % name
* warnings.warn(msg)
* continue # <<<<<<<<<<<<<<
* # get number of dimensions.
* with nogil:
*/
- goto __pyx_L47_except_continue;
+ goto __pyx_L46_except_continue;
break;
}
}
- __pyx_L48:;
+ __pyx_L47:;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- goto __pyx_L38_exception_handled;
- __pyx_L47_except_continue:;
+ goto __pyx_L37_exception_handled;
+ __pyx_L46_except_continue:;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- goto __pyx_L43_try_continue;
+ goto __pyx_L42_try_continue;
}
- goto __pyx_L39_except_error;
- __pyx_L39_except_error:;
+ goto __pyx_L38_except_error;
+ __pyx_L38_except_error:;
- /* "netCDF4/_netCDF4.pyx":1458
- * endianness = '>'
+ /* "netCDF4/_netCDF4.pyx":1468
+ * endianness = '>'
* # check to see if it is a supported user-defined type.
* try: # <<<<<<<<<<<<<<
* datatype = _nctonptype[xtype]
* if endianness is not None:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
goto __pyx_L1_error;
- __pyx_L43_try_continue:;
+ __pyx_L42_try_continue:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
goto __pyx_L15_continue;
- __pyx_L38_exception_handled:;
+ __pyx_L37_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_12, __pyx_t_13);
- __pyx_L44_try_end:;
+ __pyx_L43_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":1498
+ /* "netCDF4/_netCDF4.pyx":1508
* continue
* # get number of dimensions.
* with nogil: # <<<<<<<<<<<<<<
@@ -10424,7 +10574,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1499
+ /* "netCDF4/_netCDF4.pyx":1509
* # get number of dimensions.
* with nogil:
* ierr = nc_inq_varndims(_grpid, varid, &numdims) # <<<<<<<<<<<<<<
@@ -10434,7 +10584,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_varndims(__pyx_v__grpid, __pyx_v_varid, (&__pyx_v_numdims));
}
- /* "netCDF4/_netCDF4.pyx":1498
+ /* "netCDF4/_netCDF4.pyx":1508
* continue
* # get number of dimensions.
* with nogil: # <<<<<<<<<<<<<<
@@ -10446,13 +10596,13 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#ifdef WITH_THREAD
Py_BLOCK_THREADS
#endif
- goto __pyx_L88;
+ goto __pyx_L87;
}
- __pyx_L88:;
+ __pyx_L87:;
}
}
- /* "netCDF4/_netCDF4.pyx":1500
+ /* "netCDF4/_netCDF4.pyx":1510
* with nogil:
* ierr = nc_inq_varndims(_grpid, varid, &numdims)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -10462,7 +10612,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_14 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":1501
+ /* "netCDF4/_netCDF4.pyx":1511
* ierr = nc_inq_varndims(_grpid, varid, &numdims)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -10470,22 +10620,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* # get dimension ids.
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_10 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_10);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1511, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1500
+ /* "netCDF4/_netCDF4.pyx":1510
* with nogil:
* ierr = nc_inq_varndims(_grpid, varid, &numdims)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -10494,7 +10644,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1502
+ /* "netCDF4/_netCDF4.pyx":1512
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* dimids = <int *>malloc(sizeof(int) * numdims) # <<<<<<<<<<<<<<
@@ -10503,7 +10653,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
__pyx_v_dimids = ((int *)malloc(((sizeof(int)) * __pyx_v_numdims)));
- /* "netCDF4/_netCDF4.pyx":1504
+ /* "netCDF4/_netCDF4.pyx":1514
* dimids = <int *>malloc(sizeof(int) * numdims)
* # get dimension ids.
* with nogil: # <<<<<<<<<<<<<<
@@ -10517,7 +10667,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":1505
+ /* "netCDF4/_netCDF4.pyx":1515
* # get dimension ids.
* with nogil:
* ierr = nc_inq_vardimid(_grpid, varid, dimids) # <<<<<<<<<<<<<<
@@ -10527,7 +10677,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_v_ierr = nc_inq_vardimid(__pyx_v__grpid, __pyx_v_varid, __pyx_v_dimids);
}
- /* "netCDF4/_netCDF4.pyx":1504
+ /* "netCDF4/_netCDF4.pyx":1514
* dimids = <int *>malloc(sizeof(int) * numdims)
* # get dimension ids.
* with nogil: # <<<<<<<<<<<<<<
@@ -10539,13 +10689,13 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
#ifdef WITH_THREAD
Py_BLOCK_THREADS
#endif
- goto __pyx_L94;
+ goto __pyx_L93;
}
- __pyx_L94:;
+ __pyx_L93:;
}
}
- /* "netCDF4/_netCDF4.pyx":1506
+ /* "netCDF4/_netCDF4.pyx":1516
* with nogil:
* ierr = nc_inq_vardimid(_grpid, varid, dimids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -10555,7 +10705,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_14 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":1507
+ /* "netCDF4/_netCDF4.pyx":1517
* ierr = nc_inq_vardimid(_grpid, varid, dimids)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -10563,22 +10713,22 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* # if not found in current group, look in parents.
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_10 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1517, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1517, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_10);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1517, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1517, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1506
+ /* "netCDF4/_netCDF4.pyx":1516
* with nogil:
* ierr = nc_inq_vardimid(_grpid, varid, dimids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -10587,19 +10737,19 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1513
+ /* "netCDF4/_netCDF4.pyx":1523
* # and so does it's parent - can a variable in grp1
* # use the 'foo' dimension from the parent?
* dimensions = [] # <<<<<<<<<<<<<<
* for nn from 0 <= nn < numdims:
* grp = group
*/
- __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1513; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyList_New(0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1523, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_XDECREF_SET(__pyx_v_dimensions, ((PyObject*)__pyx_t_10));
__pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":1514
+ /* "netCDF4/_netCDF4.pyx":1524
* # use the 'foo' dimension from the parent?
* dimensions = []
* for nn from 0 <= nn < numdims: # <<<<<<<<<<<<<<
@@ -10609,7 +10759,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_15 = __pyx_v_numdims;
for (__pyx_v_nn = 0; __pyx_v_nn < __pyx_t_15; __pyx_v_nn++) {
- /* "netCDF4/_netCDF4.pyx":1515
+ /* "netCDF4/_netCDF4.pyx":1525
* dimensions = []
* for nn from 0 <= nn < numdims:
* grp = group # <<<<<<<<<<<<<<
@@ -10619,7 +10769,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_INCREF(__pyx_v_group);
__Pyx_XDECREF_SET(__pyx_v_grp, __pyx_v_group);
- /* "netCDF4/_netCDF4.pyx":1516
+ /* "netCDF4/_netCDF4.pyx":1526
* for nn from 0 <= nn < numdims:
* grp = group
* found = False # <<<<<<<<<<<<<<
@@ -10628,7 +10778,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
__pyx_v_found = 0;
- /* "netCDF4/_netCDF4.pyx":1517
+ /* "netCDF4/_netCDF4.pyx":1527
* grp = group
* found = False
* while not found: # <<<<<<<<<<<<<<
@@ -10639,16 +10789,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_14 = ((!(__pyx_v_found != 0)) != 0);
if (!__pyx_t_14) break;
- /* "netCDF4/_netCDF4.pyx":1518
+ /* "netCDF4/_netCDF4.pyx":1528
* found = False
* while not found:
* for key, value in grp.dimensions.items(): # <<<<<<<<<<<<<<
* if value._dimid == dimids[nn]:
* dimensions.append(key)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_items); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_items); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -10662,10 +10812,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
}
}
if (__pyx_t_1) {
- __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_10 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1528, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -10673,9 +10823,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_t_6 = __pyx_t_10; __Pyx_INCREF(__pyx_t_6); __pyx_t_9 = 0;
__pyx_t_26 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_26 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_26 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 1528, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
for (;;) {
@@ -10683,17 +10833,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_10 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_10); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_10); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 1528, __pyx_L1_error)
#else
- __pyx_t_10 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_10); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_10); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 1528, __pyx_L1_error)
#else
- __pyx_t_10 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
#endif
}
@@ -10703,7 +10853,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 1528, __pyx_L1_error)
}
break;
}
@@ -10719,7 +10869,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1528, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -10732,66 +10882,66 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_8);
#else
- __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_7 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_GetIter(__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_27 = Py_TYPE(__pyx_t_7)->tp_iternext;
- index = 0; __pyx_t_1 = __pyx_t_27(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L102_unpacking_failed;
+ index = 0; __pyx_t_1 = __pyx_t_27(__pyx_t_7); if (unlikely(!__pyx_t_1)) goto __pyx_L101_unpacking_failed;
__Pyx_GOTREF(__pyx_t_1);
- index = 1; __pyx_t_8 = __pyx_t_27(__pyx_t_7); if (unlikely(!__pyx_t_8)) goto __pyx_L102_unpacking_failed;
+ index = 1; __pyx_t_8 = __pyx_t_27(__pyx_t_7); if (unlikely(!__pyx_t_8)) goto __pyx_L101_unpacking_failed;
__Pyx_GOTREF(__pyx_t_8);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_27(__pyx_t_7), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_27(__pyx_t_7), 2) < 0) __PYX_ERR(0, 1528, __pyx_L1_error)
__pyx_t_27 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- goto __pyx_L103_unpacking_done;
- __pyx_L102_unpacking_failed:;
+ goto __pyx_L102_unpacking_done;
+ __pyx_L101_unpacking_failed:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_27 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_L103_unpacking_done:;
+ __PYX_ERR(0, 1528, __pyx_L1_error)
+ __pyx_L102_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_1);
__pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_8);
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1519
+ /* "netCDF4/_netCDF4.pyx":1529
* while not found:
* for key, value in grp.dimensions.items():
* if value._dimid == dimids[nn]: # <<<<<<<<<<<<<<
* dimensions.append(key)
* found = True
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_dimid); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_value, __pyx_n_s_dimid); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1529, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_8 = __Pyx_PyInt_From_int((__pyx_v_dimids[__pyx_v_nn])); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_From_int((__pyx_v_dimids[__pyx_v_nn])); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1529, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_10, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_10, __pyx_t_8, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1529, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_14 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 1529, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":1520
+ /* "netCDF4/_netCDF4.pyx":1530
* for key, value in grp.dimensions.items():
* if value._dimid == dimids[nn]:
* dimensions.append(key) # <<<<<<<<<<<<<<
* found = True
* break
*/
- __pyx_t_28 = __Pyx_PyList_Append(__pyx_v_dimensions, __pyx_v_key); if (unlikely(__pyx_t_28 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_28 = __Pyx_PyList_Append(__pyx_v_dimensions, __pyx_v_key); if (unlikely(__pyx_t_28 == -1)) __PYX_ERR(0, 1530, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1521
+ /* "netCDF4/_netCDF4.pyx":1531
* if value._dimid == dimids[nn]:
* dimensions.append(key)
* found = True # <<<<<<<<<<<<<<
@@ -10800,16 +10950,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
__pyx_v_found = 1;
- /* "netCDF4/_netCDF4.pyx":1522
+ /* "netCDF4/_netCDF4.pyx":1532
* dimensions.append(key)
* found = True
* break # <<<<<<<<<<<<<<
* grp = grp.parent
* free(dimids)
*/
- goto __pyx_L101_break;
+ goto __pyx_L100_break;
- /* "netCDF4/_netCDF4.pyx":1519
+ /* "netCDF4/_netCDF4.pyx":1529
* while not found:
* for key, value in grp.dimensions.items():
* if value._dimid == dimids[nn]: # <<<<<<<<<<<<<<
@@ -10818,7 +10968,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1518
+ /* "netCDF4/_netCDF4.pyx":1528
* found = False
* while not found:
* for key, value in grp.dimensions.items(): # <<<<<<<<<<<<<<
@@ -10826,24 +10976,24 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* dimensions.append(key)
*/
}
- __pyx_L101_break:;
+ __pyx_L100_break:;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1523
+ /* "netCDF4/_netCDF4.pyx":1533
* found = True
* break
* grp = grp.parent # <<<<<<<<<<<<<<
* free(dimids)
* # create new variable instance.
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_parent); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_parent); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF_SET(__pyx_v_grp, __pyx_t_6);
__pyx_t_6 = 0;
}
}
- /* "netCDF4/_netCDF4.pyx":1524
+ /* "netCDF4/_netCDF4.pyx":1534
* break
* grp = grp.parent
* free(dimids) # <<<<<<<<<<<<<<
@@ -10852,24 +11002,24 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
free(__pyx_v_dimids);
- /* "netCDF4/_netCDF4.pyx":1526
+ /* "netCDF4/_netCDF4.pyx":1536
* free(dimids)
* # create new variable instance.
* if endianness == '>': # <<<<<<<<<<<<<<
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='big')
* elif endianness == '<':
*/
- __pyx_t_14 = (__Pyx_PyString_Equals(__pyx_v_endianness, __pyx_kp_s__15, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1526; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = (__Pyx_PyString_Equals(__pyx_v_endianness, __pyx_kp_s__15, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 1536, __pyx_L1_error)
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":1527
+ /* "netCDF4/_netCDF4.pyx":1537
* # create new variable instance.
* if endianness == '>':
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='big') # <<<<<<<<<<<<<<
* elif endianness == '<':
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='little')
*/
- __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1537, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -10883,48 +11033,48 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_INCREF(__pyx_v_dimensions);
__Pyx_GIVEREF(__pyx_v_dimensions);
PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_v_dimensions);
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1537, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_varid); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_varid); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1537, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_id, __pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_id, __pyx_t_8) < 0) __PYX_ERR(0, 1537, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_endian, __pyx_n_s_big) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_endian, __pyx_n_s_big) < 0) __PYX_ERR(0, 1537, __pyx_L1_error)
+ __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1537, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_variables, __pyx_v_name, __pyx_t_8) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_variables, __pyx_v_name, __pyx_t_8) < 0)) __PYX_ERR(0, 1537, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1526
+ /* "netCDF4/_netCDF4.pyx":1536
* free(dimids)
* # create new variable instance.
* if endianness == '>': # <<<<<<<<<<<<<<
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='big')
* elif endianness == '<':
*/
- goto __pyx_L105;
+ goto __pyx_L104;
}
- /* "netCDF4/_netCDF4.pyx":1528
+ /* "netCDF4/_netCDF4.pyx":1538
* if endianness == '>':
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='big')
* elif endianness == '<': # <<<<<<<<<<<<<<
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='little')
* else:
*/
- __pyx_t_14 = (__Pyx_PyString_Equals(__pyx_v_endianness, __pyx_kp_s__14, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1528; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = (__Pyx_PyString_Equals(__pyx_v_endianness, __pyx_kp_s__14, Py_EQ)); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 1538, __pyx_L1_error)
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":1529
+ /* "netCDF4/_netCDF4.pyx":1539
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='big')
* elif endianness == '<':
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='little') # <<<<<<<<<<<<<<
* else:
* variables[name] = Variable(group, name, datatype, dimensions, id=varid)
*/
- __pyx_t_8 = PyTuple_New(4); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1539, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -10938,31 +11088,31 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_INCREF(__pyx_v_dimensions);
__Pyx_GIVEREF(__pyx_v_dimensions);
PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_v_dimensions);
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1539, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_varid); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_varid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1539, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_id, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_id, __pyx_t_6) < 0) __PYX_ERR(0, 1539, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_endian, __pyx_n_s_little) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_t_8, __pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_endian, __pyx_n_s_little) < 0) __PYX_ERR(0, 1539, __pyx_L1_error)
+ __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_t_8, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1539, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_variables, __pyx_v_name, __pyx_t_6) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_variables, __pyx_v_name, __pyx_t_6) < 0)) __PYX_ERR(0, 1539, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1528
+ /* "netCDF4/_netCDF4.pyx":1538
* if endianness == '>':
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='big')
* elif endianness == '<': # <<<<<<<<<<<<<<
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='little')
* else:
*/
- goto __pyx_L105;
+ goto __pyx_L104;
}
- /* "netCDF4/_netCDF4.pyx":1531
+ /* "netCDF4/_netCDF4.pyx":1541
* variables[name] = Variable(group, name, datatype, dimensions, id=varid, endian='little')
* else:
* variables[name] = Variable(group, name, datatype, dimensions, id=varid) # <<<<<<<<<<<<<<
@@ -10970,7 +11120,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
* return variables
*/
/*else*/ {
- __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1531; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1541, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -10984,24 +11134,24 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__Pyx_INCREF(__pyx_v_dimensions);
__Pyx_GIVEREF(__pyx_v_dimensions);
PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_v_dimensions);
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1531; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1541, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_varid); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1531; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_varid); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1541, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_id, __pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1531; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_id, __pyx_t_8) < 0) __PYX_ERR(0, 1541, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1531; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1541, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_variables, __pyx_v_name, __pyx_t_8) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1531; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_variables, __pyx_v_name, __pyx_t_8) < 0)) __PYX_ERR(0, 1541, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
- __pyx_L105:;
+ __pyx_L104:;
__pyx_L15_continue:;
}
- /* "netCDF4/_netCDF4.pyx":1532
+ /* "netCDF4/_netCDF4.pyx":1542
* else:
* variables[name] = Variable(group, name, datatype, dimensions, id=varid)
* free(varids) # free pointer holding variable ids. # <<<<<<<<<<<<<<
@@ -11010,7 +11160,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
free(__pyx_v_varids);
- /* "netCDF4/_netCDF4.pyx":1418
+ /* "netCDF4/_netCDF4.pyx":1431
* # create empty dictionary for variables.
* variables = OrderedDict()
* if numvars > 0: # <<<<<<<<<<<<<<
@@ -11019,7 +11169,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
*/
}
- /* "netCDF4/_netCDF4.pyx":1533
+ /* "netCDF4/_netCDF4.pyx":1543
* variables[name] = Variable(group, name, datatype, dimensions, id=varid)
* free(varids) # free pointer holding variable ids.
* return variables # <<<<<<<<<<<<<<
@@ -11031,7 +11181,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
__pyx_r = __pyx_v_variables;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1401
+ /* "netCDF4/_netCDF4.pyx":1414
* return groups
*
* cdef _get_vars(group): # <<<<<<<<<<<<<<
@@ -11068,7 +11218,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__get_vars(PyObject *__pyx_v_group) {
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1668
+/* "netCDF4/_netCDF4.pyx":1678
* the parent Dataset or Group."""
*
* def __init__(self, filename, mode='r', clobber=True, format='NETCDF4', # <<<<<<<<<<<<<<
@@ -11091,9 +11241,6 @@ static int __pyx_pw_7netCDF4_8_netCDF4_7Dataset_1__init__(PyObject *__pyx_v_self
PyObject *__pyx_v_persist = 0;
PyObject *__pyx_v_keepweakref = 0;
CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -11106,7 +11253,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_7Dataset_1__init__(PyObject *__pyx_v_self
values[2] = ((PyObject *)Py_True);
values[3] = ((PyObject *)__pyx_n_s_NETCDF4);
- /* "netCDF4/_netCDF4.pyx":1669
+ /* "netCDF4/_netCDF4.pyx":1679
*
* def __init__(self, filename, mode='r', clobber=True, format='NETCDF4',
* diskless=False, persist=False, keepweakref=False, **kwargs): # <<<<<<<<<<<<<<
@@ -11167,7 +11314,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_7Dataset_1__init__(PyObject *__pyx_v_self
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1678, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -11192,7 +11339,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_7Dataset_1__init__(PyObject *__pyx_v_self
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1668; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 1, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1678, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
@@ -11201,7 +11348,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_7Dataset_1__init__(PyObject *__pyx_v_self
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(((struct __pyx_obj_7netCDF4_8_netCDF4_Dataset *)__pyx_v_self), __pyx_v_filename, __pyx_v_mode, __pyx_v_clobber, __pyx_v_format, __pyx_v_diskless, __pyx_v_persist, __pyx_v_keepweakref, __pyx_v_kwargs);
- /* "netCDF4/_netCDF4.pyx":1668
+ /* "netCDF4/_netCDF4.pyx":1678
* the parent Dataset or Group."""
*
* def __init__(self, filename, mode='r', clobber=True, format='NETCDF4', # <<<<<<<<<<<<<<
@@ -11232,12 +11379,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *(*__pyx_t_10)(PyObject *);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
- /* "netCDF4/_netCDF4.pyx":1737
+ /* "netCDF4/_netCDF4.pyx":1747
* cdef char namstring[NC_MAX_NAME+1]
* # flag to indicate that Variables in this Dataset support orthogonal indexing.
* self.__orthogonal_indexing__ = True # <<<<<<<<<<<<<<
@@ -11250,54 +11394,54 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__Pyx_DECREF(__pyx_v_self->__orthogonal_indexing__);
__pyx_v_self->__orthogonal_indexing__ = Py_True;
- /* "netCDF4/_netCDF4.pyx":1738
+ /* "netCDF4/_netCDF4.pyx":1748
* # flag to indicate that Variables in this Dataset support orthogonal indexing.
* self.__orthogonal_indexing__ = True
* if diskless and __netcdf4libversion__ < '4.2.1': # <<<<<<<<<<<<<<
* #diskless = False # don't raise error, instead silently ignore
* raise ValueError('diskless mode requires netcdf lib >= 4.2.1, you have %s' % __netcdf4libversion__)
*/
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1748, __pyx_L1_error)
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_kp_s_4_2_1, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_kp_s_4_2_1, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1748, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1748, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1740
+ /* "netCDF4/_netCDF4.pyx":1750
* if diskless and __netcdf4libversion__ < '4.2.1':
* #diskless = False # don't raise error, instead silently ignore
* raise ValueError('diskless mode requires netcdf lib >= 4.2.1, you have %s' % __netcdf4libversion__) # <<<<<<<<<<<<<<
* bytestr = _strencode(str(filename))
* path = bytestr
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_diskless_mode_requires_netcdf_li, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_diskless_mode_requires_netcdf_li, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1750, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1738
+ /* "netCDF4/_netCDF4.pyx":1748
* # flag to indicate that Variables in this Dataset support orthogonal indexing.
* self.__orthogonal_indexing__ = True
* if diskless and __netcdf4libversion__ < '4.2.1': # <<<<<<<<<<<<<<
@@ -11306,115 +11450,115 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
*/
}
- /* "netCDF4/_netCDF4.pyx":1741
+ /* "netCDF4/_netCDF4.pyx":1751
* #diskless = False # don't raise error, instead silently ignore
* raise ValueError('diskless mode requires netcdf lib >= 4.2.1, you have %s' % __netcdf4libversion__)
* bytestr = _strencode(str(filename)) # <<<<<<<<<<<<<<
* path = bytestr
* if mode == 'w':
*/
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1751, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_filename);
__Pyx_GIVEREF(__pyx_v_filename);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_filename);
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1751, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1751, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_bytestr = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":1742
+ /* "netCDF4/_netCDF4.pyx":1752
* raise ValueError('diskless mode requires netcdf lib >= 4.2.1, you have %s' % __netcdf4libversion__)
* bytestr = _strencode(str(filename))
* path = bytestr # <<<<<<<<<<<<<<
* if mode == 'w':
* _set_default_format(format=format)
*/
- __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1742; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(0, 1752, __pyx_L1_error)
__pyx_v_path = __pyx_t_5;
- /* "netCDF4/_netCDF4.pyx":1743
+ /* "netCDF4/_netCDF4.pyx":1753
* bytestr = _strencode(str(filename))
* path = bytestr
* if mode == 'w': # <<<<<<<<<<<<<<
* _set_default_format(format=format)
* if clobber:
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_w, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1743; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_w, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1753, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1744
+ /* "netCDF4/_netCDF4.pyx":1754
* path = bytestr
* if mode == 'w':
* _set_default_format(format=format) # <<<<<<<<<<<<<<
* if clobber:
* if diskless:
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_set_default_format); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1744; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_set_default_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1754, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1744; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1754, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_format, __pyx_v_format) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1744; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1744; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_format, __pyx_v_format) < 0) __PYX_ERR(0, 1754, __pyx_L1_error)
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1754, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1745
+ /* "netCDF4/_netCDF4.pyx":1755
* if mode == 'w':
* _set_default_format(format=format)
* if clobber: # <<<<<<<<<<<<<<
* if diskless:
* if persist:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_clobber); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1745; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_clobber); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1755, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1746
+ /* "netCDF4/_netCDF4.pyx":1756
* _set_default_format(format=format)
* if clobber:
* if diskless: # <<<<<<<<<<<<<<
* if persist:
* ierr = nc_create(path, NC_WRITE | NC_CLOBBER | NC_DISKLESS , &grpid)
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1746; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1756, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1747
+ /* "netCDF4/_netCDF4.pyx":1757
* if clobber:
* if diskless:
* if persist: # <<<<<<<<<<<<<<
* ierr = nc_create(path, NC_WRITE | NC_CLOBBER | NC_DISKLESS , &grpid)
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_persist); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1747; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_persist); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1757, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1748
+ /* "netCDF4/_netCDF4.pyx":1758
* if diskless:
* if persist:
* ierr = nc_create(path, NC_WRITE | NC_CLOBBER | NC_DISKLESS , &grpid) # <<<<<<<<<<<<<<
* else:
* ierr = nc_create(path, NC_CLOBBER | NC_DISKLESS , &grpid)
*/
- __pyx_t_6 = __Pyx_PyInt_From_int((NC_WRITE | NC_CLOBBER)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_int((NC_WRITE | NC_CLOBBER)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1758, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1758, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1758, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1758, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_ierr = nc_create(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
- /* "netCDF4/_netCDF4.pyx":1747
+ /* "netCDF4/_netCDF4.pyx":1757
* if clobber:
* if diskless:
* if persist: # <<<<<<<<<<<<<<
@@ -11424,7 +11568,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":1750
+ /* "netCDF4/_netCDF4.pyx":1760
* ierr = nc_create(path, NC_WRITE | NC_CLOBBER | NC_DISKLESS , &grpid)
* else:
* ierr = nc_create(path, NC_CLOBBER | NC_DISKLESS , &grpid) # <<<<<<<<<<<<<<
@@ -11432,21 +11576,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
* ierr = nc_create(path, NC_CLOBBER, &grpid)
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyInt_From_int(NC_CLOBBER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1750; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int(NC_CLOBBER); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1750; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1750; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1750; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1760, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_ierr = nc_create(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
}
__pyx_L9:;
- /* "netCDF4/_netCDF4.pyx":1746
+ /* "netCDF4/_netCDF4.pyx":1756
* _set_default_format(format=format)
* if clobber:
* if diskless: # <<<<<<<<<<<<<<
@@ -11456,7 +11600,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L8;
}
- /* "netCDF4/_netCDF4.pyx":1752
+ /* "netCDF4/_netCDF4.pyx":1762
* ierr = nc_create(path, NC_CLOBBER | NC_DISKLESS , &grpid)
* else:
* ierr = nc_create(path, NC_CLOBBER, &grpid) # <<<<<<<<<<<<<<
@@ -11468,7 +11612,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
__pyx_L8:;
- /* "netCDF4/_netCDF4.pyx":1745
+ /* "netCDF4/_netCDF4.pyx":1755
* if mode == 'w':
* _set_default_format(format=format)
* if clobber: # <<<<<<<<<<<<<<
@@ -11478,7 +11622,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L7;
}
- /* "netCDF4/_netCDF4.pyx":1754
+ /* "netCDF4/_netCDF4.pyx":1764
* ierr = nc_create(path, NC_CLOBBER, &grpid)
* else:
* if diskless: # <<<<<<<<<<<<<<
@@ -11486,39 +11630,39 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
* ierr = nc_create(path, NC_WRITE | NC_NOCLOBBER | NC_DISKLESS , &grpid)
*/
/*else*/ {
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1754; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1764, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1755
+ /* "netCDF4/_netCDF4.pyx":1765
* else:
* if diskless:
* if persist: # <<<<<<<<<<<<<<
* ierr = nc_create(path, NC_WRITE | NC_NOCLOBBER | NC_DISKLESS , &grpid)
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_persist); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_persist); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1765, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1756
+ /* "netCDF4/_netCDF4.pyx":1766
* if diskless:
* if persist:
* ierr = nc_create(path, NC_WRITE | NC_NOCLOBBER | NC_DISKLESS , &grpid) # <<<<<<<<<<<<<<
* else:
* ierr = nc_create(path, NC_NOCLOBBER | NC_DISKLESS , &grpid)
*/
- __pyx_t_6 = __Pyx_PyInt_From_int((NC_WRITE | NC_NOCLOBBER)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_int((NC_WRITE | NC_NOCLOBBER)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1766, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_ierr = nc_create(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
- /* "netCDF4/_netCDF4.pyx":1755
+ /* "netCDF4/_netCDF4.pyx":1765
* else:
* if diskless:
* if persist: # <<<<<<<<<<<<<<
@@ -11528,7 +11672,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L11;
}
- /* "netCDF4/_netCDF4.pyx":1758
+ /* "netCDF4/_netCDF4.pyx":1768
* ierr = nc_create(path, NC_WRITE | NC_NOCLOBBER | NC_DISKLESS , &grpid)
* else:
* ierr = nc_create(path, NC_NOCLOBBER | NC_DISKLESS , &grpid) # <<<<<<<<<<<<<<
@@ -11536,21 +11680,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
* ierr = nc_create(path, NC_NOCLOBBER, &grpid)
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyInt_From_int(NC_NOCLOBBER); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int(NC_NOCLOBBER); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1768, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1768, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1768, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1768, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_ierr = nc_create(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
}
__pyx_L11:;
- /* "netCDF4/_netCDF4.pyx":1754
+ /* "netCDF4/_netCDF4.pyx":1764
* ierr = nc_create(path, NC_CLOBBER, &grpid)
* else:
* if diskless: # <<<<<<<<<<<<<<
@@ -11560,7 +11704,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L10;
}
- /* "netCDF4/_netCDF4.pyx":1760
+ /* "netCDF4/_netCDF4.pyx":1770
* ierr = nc_create(path, NC_NOCLOBBER | NC_DISKLESS , &grpid)
* else:
* ierr = nc_create(path, NC_NOCLOBBER, &grpid) # <<<<<<<<<<<<<<
@@ -11574,25 +11718,25 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
__pyx_L7:;
- /* "netCDF4/_netCDF4.pyx":1765
+ /* "netCDF4/_netCDF4.pyx":1775
* # format to NETCDF4). This bug should be fixed in version
* # 4.3.0 of the netcdf library (add a version check here?).
* _set_default_format(format='NETCDF3_64BIT_OFFSET') # <<<<<<<<<<<<<<
* elif mode == 'r':
* if diskless:
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_set_default_format); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_set_default_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1775, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1775, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_format, __pyx_n_s_NETCDF3_64BIT_OFFSET) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_format, __pyx_n_s_NETCDF3_64BIT_OFFSET) < 0) __PYX_ERR(0, 1775, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1775, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":1743
+ /* "netCDF4/_netCDF4.pyx":1753
* bytestr = _strencode(str(filename))
* path = bytestr
* if mode == 'w': # <<<<<<<<<<<<<<
@@ -11602,46 +11746,46 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L6;
}
- /* "netCDF4/_netCDF4.pyx":1766
+ /* "netCDF4/_netCDF4.pyx":1776
* # 4.3.0 of the netcdf library (add a version check here?).
* _set_default_format(format='NETCDF3_64BIT_OFFSET')
* elif mode == 'r': # <<<<<<<<<<<<<<
* if diskless:
* ierr = nc_open(path, NC_NOWRITE | NC_DISKLESS, &grpid)
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_r, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1766; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_r, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1776, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1767
+ /* "netCDF4/_netCDF4.pyx":1777
* _set_default_format(format='NETCDF3_64BIT_OFFSET')
* elif mode == 'r':
* if diskless: # <<<<<<<<<<<<<<
* ierr = nc_open(path, NC_NOWRITE | NC_DISKLESS, &grpid)
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1767; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1777, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1768
+ /* "netCDF4/_netCDF4.pyx":1778
* elif mode == 'r':
* if diskless:
* ierr = nc_open(path, NC_NOWRITE | NC_DISKLESS, &grpid) # <<<<<<<<<<<<<<
* else:
* ierr = nc_open(path, NC_NOWRITE, &grpid)
*/
- __pyx_t_3 = __Pyx_PyInt_From_int(NC_NOWRITE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int(NC_NOWRITE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1778, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1778, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1778, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1778, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_ierr = nc_open(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
- /* "netCDF4/_netCDF4.pyx":1767
+ /* "netCDF4/_netCDF4.pyx":1777
* _set_default_format(format='NETCDF3_64BIT_OFFSET')
* elif mode == 'r':
* if diskless: # <<<<<<<<<<<<<<
@@ -11651,7 +11795,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L12;
}
- /* "netCDF4/_netCDF4.pyx":1770
+ /* "netCDF4/_netCDF4.pyx":1780
* ierr = nc_open(path, NC_NOWRITE | NC_DISKLESS, &grpid)
* else:
* ierr = nc_open(path, NC_NOWRITE, &grpid) # <<<<<<<<<<<<<<
@@ -11663,7 +11807,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
__pyx_L12:;
- /* "netCDF4/_netCDF4.pyx":1766
+ /* "netCDF4/_netCDF4.pyx":1776
* # 4.3.0 of the netcdf library (add a version check here?).
* _set_default_format(format='NETCDF3_64BIT_OFFSET')
* elif mode == 'r': # <<<<<<<<<<<<<<
@@ -11673,54 +11817,54 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L6;
}
- /* "netCDF4/_netCDF4.pyx":1771
+ /* "netCDF4/_netCDF4.pyx":1781
* else:
* ierr = nc_open(path, NC_NOWRITE, &grpid)
* elif mode == 'r+' or mode == 'a': # <<<<<<<<<<<<<<
* if diskless:
* ierr = nc_open(path, NC_WRITE | NC_DISKLESS, &grpid)
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_kp_s_r_2, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1771; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_kp_s_r_2, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1781, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L13_bool_binop_done;
}
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_a, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1771; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_a, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1781, __pyx_L1_error)
__pyx_t_1 = __pyx_t_2;
__pyx_L13_bool_binop_done:;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1772
+ /* "netCDF4/_netCDF4.pyx":1782
* ierr = nc_open(path, NC_NOWRITE, &grpid)
* elif mode == 'r+' or mode == 'a':
* if diskless: # <<<<<<<<<<<<<<
* ierr = nc_open(path, NC_WRITE | NC_DISKLESS, &grpid)
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1772; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1782, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1773
+ /* "netCDF4/_netCDF4.pyx":1783
* elif mode == 'r+' or mode == 'a':
* if diskless:
* ierr = nc_open(path, NC_WRITE | NC_DISKLESS, &grpid) # <<<<<<<<<<<<<<
* else:
* ierr = nc_open(path, NC_WRITE, &grpid)
*/
- __pyx_t_6 = __Pyx_PyInt_From_int(NC_WRITE); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_int(NC_WRITE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1783, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_ierr = nc_open(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
- /* "netCDF4/_netCDF4.pyx":1772
+ /* "netCDF4/_netCDF4.pyx":1782
* ierr = nc_open(path, NC_NOWRITE, &grpid)
* elif mode == 'r+' or mode == 'a':
* if diskless: # <<<<<<<<<<<<<<
@@ -11730,7 +11874,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L15;
}
- /* "netCDF4/_netCDF4.pyx":1775
+ /* "netCDF4/_netCDF4.pyx":1785
* ierr = nc_open(path, NC_WRITE | NC_DISKLESS, &grpid)
* else:
* ierr = nc_open(path, NC_WRITE, &grpid) # <<<<<<<<<<<<<<
@@ -11742,7 +11886,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
__pyx_L15:;
- /* "netCDF4/_netCDF4.pyx":1771
+ /* "netCDF4/_netCDF4.pyx":1781
* else:
* ierr = nc_open(path, NC_NOWRITE, &grpid)
* elif mode == 'r+' or mode == 'a': # <<<<<<<<<<<<<<
@@ -11752,54 +11896,54 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L6;
}
- /* "netCDF4/_netCDF4.pyx":1776
+ /* "netCDF4/_netCDF4.pyx":1786
* else:
* ierr = nc_open(path, NC_WRITE, &grpid)
* elif mode == 'as' or mode == 'r+s': # <<<<<<<<<<<<<<
* if diskless:
* ierr = nc_open(path, NC_SHARE | NC_DISKLESS, &grpid)
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_as, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1776; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_as, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1786, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L16_bool_binop_done;
}
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_kp_s_r_s, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1776; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_kp_s_r_s, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1786, __pyx_L1_error)
__pyx_t_1 = __pyx_t_2;
__pyx_L16_bool_binop_done:;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1777
+ /* "netCDF4/_netCDF4.pyx":1787
* ierr = nc_open(path, NC_WRITE, &grpid)
* elif mode == 'as' or mode == 'r+s':
* if diskless: # <<<<<<<<<<<<<<
* ierr = nc_open(path, NC_SHARE | NC_DISKLESS, &grpid)
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1777; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1787, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1778
+ /* "netCDF4/_netCDF4.pyx":1788
* elif mode == 'as' or mode == 'r+s':
* if diskless:
* ierr = nc_open(path, NC_SHARE | NC_DISKLESS, &grpid) # <<<<<<<<<<<<<<
* else:
* ierr = nc_open(path, NC_SHARE, &grpid)
*/
- __pyx_t_3 = __Pyx_PyInt_From_int(NC_SHARE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int(NC_SHARE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1788, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1788, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1788, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1788, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_ierr = nc_open(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
- /* "netCDF4/_netCDF4.pyx":1777
+ /* "netCDF4/_netCDF4.pyx":1787
* ierr = nc_open(path, NC_WRITE, &grpid)
* elif mode == 'as' or mode == 'r+s':
* if diskless: # <<<<<<<<<<<<<<
@@ -11809,7 +11953,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L18;
}
- /* "netCDF4/_netCDF4.pyx":1780
+ /* "netCDF4/_netCDF4.pyx":1790
* ierr = nc_open(path, NC_SHARE | NC_DISKLESS, &grpid)
* else:
* ierr = nc_open(path, NC_SHARE, &grpid) # <<<<<<<<<<<<<<
@@ -11821,7 +11965,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
__pyx_L18:;
- /* "netCDF4/_netCDF4.pyx":1776
+ /* "netCDF4/_netCDF4.pyx":1786
* else:
* ierr = nc_open(path, NC_WRITE, &grpid)
* elif mode == 'as' or mode == 'r+s': # <<<<<<<<<<<<<<
@@ -11831,66 +11975,66 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L6;
}
- /* "netCDF4/_netCDF4.pyx":1781
+ /* "netCDF4/_netCDF4.pyx":1791
* else:
* ierr = nc_open(path, NC_SHARE, &grpid)
* elif mode == 'ws': # <<<<<<<<<<<<<<
* if clobber:
* if diskless:
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_ws, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1781; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_ws, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1791, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1782
+ /* "netCDF4/_netCDF4.pyx":1792
* ierr = nc_open(path, NC_SHARE, &grpid)
* elif mode == 'ws':
* if clobber: # <<<<<<<<<<<<<<
* if diskless:
* if persist:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_clobber); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1782; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_clobber); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1792, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1783
+ /* "netCDF4/_netCDF4.pyx":1793
* elif mode == 'ws':
* if clobber:
* if diskless: # <<<<<<<<<<<<<<
* if persist:
* ierr = nc_create(path, NC_WRITE | NC_SHARE | NC_CLOBBER | NC_DISKLESS , &grpid)
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1783; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1793, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1784
+ /* "netCDF4/_netCDF4.pyx":1794
* if clobber:
* if diskless:
* if persist: # <<<<<<<<<<<<<<
* ierr = nc_create(path, NC_WRITE | NC_SHARE | NC_CLOBBER | NC_DISKLESS , &grpid)
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_persist); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1784; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_persist); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1794, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1785
+ /* "netCDF4/_netCDF4.pyx":1795
* if diskless:
* if persist:
* ierr = nc_create(path, NC_WRITE | NC_SHARE | NC_CLOBBER | NC_DISKLESS , &grpid) # <<<<<<<<<<<<<<
* else:
* ierr = nc_create(path, NC_SHARE | NC_CLOBBER | NC_DISKLESS , &grpid)
*/
- __pyx_t_6 = __Pyx_PyInt_From_int(((NC_WRITE | NC_SHARE) | NC_CLOBBER)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1785; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_int(((NC_WRITE | NC_SHARE) | NC_CLOBBER)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1795, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1785; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1795, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1785; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1795, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1785; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1795, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_ierr = nc_create(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
- /* "netCDF4/_netCDF4.pyx":1784
+ /* "netCDF4/_netCDF4.pyx":1794
* if clobber:
* if diskless:
* if persist: # <<<<<<<<<<<<<<
@@ -11900,7 +12044,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L21;
}
- /* "netCDF4/_netCDF4.pyx":1787
+ /* "netCDF4/_netCDF4.pyx":1797
* ierr = nc_create(path, NC_WRITE | NC_SHARE | NC_CLOBBER | NC_DISKLESS , &grpid)
* else:
* ierr = nc_create(path, NC_SHARE | NC_CLOBBER | NC_DISKLESS , &grpid) # <<<<<<<<<<<<<<
@@ -11908,21 +12052,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
* ierr = nc_create(path, NC_SHARE | NC_CLOBBER, &grpid)
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyInt_From_int((NC_SHARE | NC_CLOBBER)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int((NC_SHARE | NC_CLOBBER)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1797, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1797, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1797, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1797, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_ierr = nc_create(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
}
__pyx_L21:;
- /* "netCDF4/_netCDF4.pyx":1783
+ /* "netCDF4/_netCDF4.pyx":1793
* elif mode == 'ws':
* if clobber:
* if diskless: # <<<<<<<<<<<<<<
@@ -11932,7 +12076,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L20;
}
- /* "netCDF4/_netCDF4.pyx":1789
+ /* "netCDF4/_netCDF4.pyx":1799
* ierr = nc_create(path, NC_SHARE | NC_CLOBBER | NC_DISKLESS , &grpid)
* else:
* ierr = nc_create(path, NC_SHARE | NC_CLOBBER, &grpid) # <<<<<<<<<<<<<<
@@ -11944,7 +12088,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
__pyx_L20:;
- /* "netCDF4/_netCDF4.pyx":1782
+ /* "netCDF4/_netCDF4.pyx":1792
* ierr = nc_open(path, NC_SHARE, &grpid)
* elif mode == 'ws':
* if clobber: # <<<<<<<<<<<<<<
@@ -11954,7 +12098,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L19;
}
- /* "netCDF4/_netCDF4.pyx":1791
+ /* "netCDF4/_netCDF4.pyx":1801
* ierr = nc_create(path, NC_SHARE | NC_CLOBBER, &grpid)
* else:
* if diskless: # <<<<<<<<<<<<<<
@@ -11962,39 +12106,39 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
* ierr = nc_create(path, NC_WRITE | NC_SHARE | NC_NOCLOBBER | NC_DISKLESS , &grpid)
*/
/*else*/ {
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1791; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_diskless); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1801, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1792
+ /* "netCDF4/_netCDF4.pyx":1802
* else:
* if diskless:
* if persist: # <<<<<<<<<<<<<<
* ierr = nc_create(path, NC_WRITE | NC_SHARE | NC_NOCLOBBER | NC_DISKLESS , &grpid)
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_persist); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1792; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_persist); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1802, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1793
+ /* "netCDF4/_netCDF4.pyx":1803
* if diskless:
* if persist:
* ierr = nc_create(path, NC_WRITE | NC_SHARE | NC_NOCLOBBER | NC_DISKLESS , &grpid) # <<<<<<<<<<<<<<
* else:
* ierr = nc_create(path, NC_SHARE | NC_NOCLOBBER | NC_DISKLESS , &grpid)
*/
- __pyx_t_6 = __Pyx_PyInt_From_int(((NC_WRITE | NC_SHARE) | NC_NOCLOBBER)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_int(((NC_WRITE | NC_SHARE) | NC_NOCLOBBER)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1803, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1803, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Or(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1803, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1803, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_ierr = nc_create(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
- /* "netCDF4/_netCDF4.pyx":1792
+ /* "netCDF4/_netCDF4.pyx":1802
* else:
* if diskless:
* if persist: # <<<<<<<<<<<<<<
@@ -12004,7 +12148,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L23;
}
- /* "netCDF4/_netCDF4.pyx":1795
+ /* "netCDF4/_netCDF4.pyx":1805
* ierr = nc_create(path, NC_WRITE | NC_SHARE | NC_NOCLOBBER | NC_DISKLESS , &grpid)
* else:
* ierr = nc_create(path, NC_SHARE | NC_NOCLOBBER | NC_DISKLESS , &grpid) # <<<<<<<<<<<<<<
@@ -12012,21 +12156,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
* ierr = nc_create(path, NC_SHARE | NC_NOCLOBBER, &grpid)
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyInt_From_int((NC_SHARE | NC_NOCLOBBER)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int((NC_SHARE | NC_NOCLOBBER)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1805, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_NC_DISKLESS); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1805, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Or(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1805, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1805, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_ierr = nc_create(__pyx_v_path, __pyx_t_7, (&__pyx_v_grpid));
}
__pyx_L23:;
- /* "netCDF4/_netCDF4.pyx":1791
+ /* "netCDF4/_netCDF4.pyx":1801
* ierr = nc_create(path, NC_SHARE | NC_CLOBBER, &grpid)
* else:
* if diskless: # <<<<<<<<<<<<<<
@@ -12036,7 +12180,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L22;
}
- /* "netCDF4/_netCDF4.pyx":1797
+ /* "netCDF4/_netCDF4.pyx":1807
* ierr = nc_create(path, NC_SHARE | NC_NOCLOBBER | NC_DISKLESS , &grpid)
* else:
* ierr = nc_create(path, NC_SHARE | NC_NOCLOBBER, &grpid) # <<<<<<<<<<<<<<
@@ -12050,7 +12194,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
__pyx_L19:;
- /* "netCDF4/_netCDF4.pyx":1781
+ /* "netCDF4/_netCDF4.pyx":1791
* else:
* ierr = nc_open(path, NC_SHARE, &grpid)
* elif mode == 'ws': # <<<<<<<<<<<<<<
@@ -12060,80 +12204,80 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L6;
}
- /* "netCDF4/_netCDF4.pyx":1799
+ /* "netCDF4/_netCDF4.pyx":1809
* ierr = nc_create(path, NC_SHARE | NC_NOCLOBBER, &grpid)
* else:
* raise ValueError("mode must be 'w', 'r', 'a' or 'r+', got '%s'" % mode) # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise IOError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
/*else*/ {
- __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_mode_must_be_w_r_a_or_r_got_s, __pyx_v_mode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_mode_must_be_w_r_a_or_r_got_s, __pyx_v_mode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1809, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1809, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1809, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1809, __pyx_L1_error)
}
__pyx_L6:;
- /* "netCDF4/_netCDF4.pyx":1800
+ /* "netCDF4/_netCDF4.pyx":1810
* else:
* raise ValueError("mode must be 'w', 'r', 'a' or 'r+', got '%s'" % mode)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise IOError((<char *>nc_strerror(ierr)).decode('ascii'))
* # data model and file format attributes
*/
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1801
+ /* "netCDF4/_netCDF4.pyx":1811
* raise ValueError("mode must be 'w', 'r', 'a' or 'r+', got '%s'" % mode)
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
+ * raise IOError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
* # data model and file format attributes
* self.data_model = _get_format(grpid)
*/
__pyx_t_5 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_6 = __Pyx_decode_c_string(__pyx_t_5, 0, strlen(__pyx_t_5), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1801; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_decode_c_string(__pyx_t_5, 0, strlen(__pyx_t_5), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1811, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1801; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1811, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1801; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1811, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1801; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1811, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1800
+ /* "netCDF4/_netCDF4.pyx":1810
* else:
* raise ValueError("mode must be 'w', 'r', 'a' or 'r+', got '%s'" % mode)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise IOError((<char *>nc_strerror(ierr)).decode('ascii'))
* # data model and file format attributes
*/
}
- /* "netCDF4/_netCDF4.pyx":1803
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ /* "netCDF4/_netCDF4.pyx":1813
+ * raise IOError((<char *>nc_strerror(ierr)).decode('ascii'))
* # data model and file format attributes
* self.data_model = _get_format(grpid) # <<<<<<<<<<<<<<
* # data_model attribute used to be file_format (versions < 1.0.8), retain
* # file_format for backwards compatibility.
*/
- __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_format(__pyx_v_grpid); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1803; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_format(__pyx_v_grpid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_v_self->data_model);
@@ -12141,7 +12285,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__pyx_v_self->data_model = __pyx_t_6;
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1806
+ /* "netCDF4/_netCDF4.pyx":1816
* # data_model attribute used to be file_format (versions < 1.0.8), retain
* # file_format for backwards compatibility.
* self.file_format = self.data_model # <<<<<<<<<<<<<<
@@ -12156,14 +12300,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__pyx_v_self->file_format = __pyx_t_6;
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1807
+ /* "netCDF4/_netCDF4.pyx":1817
* # file_format for backwards compatibility.
* self.file_format = self.data_model
* self.disk_format = _get_full_format(grpid) # <<<<<<<<<<<<<<
* # diskless read access only works with NETCDF_CLASSIC (for now)
* #ncopen = mode.startswith('a') or mode.startswith('r')
*/
- __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_full_format(__pyx_v_grpid); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1807; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_full_format(__pyx_v_grpid); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1817, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_v_self->disk_format);
@@ -12171,7 +12315,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__pyx_v_self->disk_format = __pyx_t_6;
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1812
+ /* "netCDF4/_netCDF4.pyx":1822
* #if diskless and self.data_model != 'NETCDF3_CLASSIC' and ncopen:
* # raise ValueError("diskless access only supported for NETCDF3_CLASSIC format")
* self._grpid = grpid # <<<<<<<<<<<<<<
@@ -12180,7 +12324,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
*/
__pyx_v_self->_grpid = __pyx_v_grpid;
- /* "netCDF4/_netCDF4.pyx":1813
+ /* "netCDF4/_netCDF4.pyx":1823
* # raise ValueError("diskless access only supported for NETCDF3_CLASSIC format")
* self._grpid = grpid
* self._isopen = 1 # <<<<<<<<<<<<<<
@@ -12189,7 +12333,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
*/
__pyx_v_self->_isopen = 1;
- /* "netCDF4/_netCDF4.pyx":1814
+ /* "netCDF4/_netCDF4.pyx":1824
* self._grpid = grpid
* self._isopen = 1
* self.path = '/' # <<<<<<<<<<<<<<
@@ -12202,7 +12346,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__Pyx_DECREF(__pyx_v_self->path);
__pyx_v_self->path = __pyx_kp_s__16;
- /* "netCDF4/_netCDF4.pyx":1815
+ /* "netCDF4/_netCDF4.pyx":1825
* self._isopen = 1
* self.path = '/'
* self.parent = None # <<<<<<<<<<<<<<
@@ -12215,7 +12359,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__Pyx_DECREF(__pyx_v_self->parent);
__pyx_v_self->parent = Py_None;
- /* "netCDF4/_netCDF4.pyx":1816
+ /* "netCDF4/_netCDF4.pyx":1826
* self.path = '/'
* self.parent = None
* self.keepweakref = keepweakref # <<<<<<<<<<<<<<
@@ -12228,14 +12372,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__Pyx_DECREF(__pyx_v_self->keepweakref);
__pyx_v_self->keepweakref = __pyx_v_keepweakref;
- /* "netCDF4/_netCDF4.pyx":1818
+ /* "netCDF4/_netCDF4.pyx":1828
* self.keepweakref = keepweakref
* # get compound, vlen and enum types in the root Group.
* self.cmptypes, self.vltypes, self.enumtypes = _get_types(self) # <<<<<<<<<<<<<<
* # get dimensions in the root group.
* self.dimensions = _get_dims(self)
*/
- __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_types(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_types(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if ((likely(PyTuple_CheckExact(__pyx_t_6))) || (PyList_CheckExact(__pyx_t_6))) {
PyObject* sequence = __pyx_t_6;
@@ -12247,7 +12391,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
if (unlikely(size != 3)) {
if (size > 3) __Pyx_RaiseTooManyValuesError(3);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1828, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -12263,17 +12407,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_8);
#else
- __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_8 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_9 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext;
@@ -12283,7 +12427,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__Pyx_GOTREF(__pyx_t_3);
index = 2; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L25_unpacking_failed;
__Pyx_GOTREF(__pyx_t_8);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 3) < 0) __PYX_ERR(0, 1828, __pyx_L1_error)
__pyx_t_10 = NULL;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L26_unpacking_done;
@@ -12291,7 +12435,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1828, __pyx_L1_error)
__pyx_L26_unpacking_done:;
}
__Pyx_GIVEREF(__pyx_t_4);
@@ -12310,14 +12454,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__pyx_v_self->enumtypes = __pyx_t_8;
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1820
+ /* "netCDF4/_netCDF4.pyx":1830
* self.cmptypes, self.vltypes, self.enumtypes = _get_types(self)
* # get dimensions in the root group.
* self.dimensions = _get_dims(self) # <<<<<<<<<<<<<<
* # get variables in the root Group.
* self.variables = _get_vars(self)
*/
- __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_dims(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1820; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_dims(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1830, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_v_self->dimensions);
@@ -12325,14 +12469,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__pyx_v_self->dimensions = __pyx_t_6;
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1822
+ /* "netCDF4/_netCDF4.pyx":1832
* self.dimensions = _get_dims(self)
* # get variables in the root Group.
* self.variables = _get_vars(self) # <<<<<<<<<<<<<<
* # get groups in the root Group.
* if self.data_model == 'NETCDF4':
*/
- __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_vars(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1822; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_vars(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1832, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_v_self->variables);
@@ -12340,24 +12484,24 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__pyx_v_self->variables = __pyx_t_6;
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1824
+ /* "netCDF4/_netCDF4.pyx":1834
* self.variables = _get_vars(self)
* # get groups in the root Group.
* if self.data_model == 'NETCDF4': # <<<<<<<<<<<<<<
* self.groups = _get_grps(self)
* else:
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1824; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1834, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1825
+ /* "netCDF4/_netCDF4.pyx":1835
* # get groups in the root Group.
* if self.data_model == 'NETCDF4':
* self.groups = _get_grps(self) # <<<<<<<<<<<<<<
* else:
* self.groups = OrderedDict()
*/
- __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_grps(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __pyx_f_7netCDF4_8_netCDF4__get_grps(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1835, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_v_self->groups);
@@ -12365,7 +12509,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
__pyx_v_self->groups = __pyx_t_6;
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":1824
+ /* "netCDF4/_netCDF4.pyx":1834
* self.variables = _get_vars(self)
* # get groups in the root Group.
* if self.data_model == 'NETCDF4': # <<<<<<<<<<<<<<
@@ -12375,7 +12519,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
goto __pyx_L27;
}
- /* "netCDF4/_netCDF4.pyx":1827
+ /* "netCDF4/_netCDF4.pyx":1837
* self.groups = _get_grps(self)
* else:
* self.groups = OrderedDict() # <<<<<<<<<<<<<<
@@ -12383,7 +12527,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
* # these allow Dataset objects to be used via a "with" statement.
*/
/*else*/ {
- __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1827; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1837, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) {
@@ -12396,10 +12540,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
}
if (__pyx_t_3) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1827; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1837, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1827; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1837, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
@@ -12411,7 +12555,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
}
__pyx_L27:;
- /* "netCDF4/_netCDF4.pyx":1668
+ /* "netCDF4/_netCDF4.pyx":1678
* the parent Dataset or Group."""
*
* def __init__(self, filename, mode='r', clobber=True, format='NETCDF4', # <<<<<<<<<<<<<<
@@ -12436,7 +12580,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset___init__(struct __pyx_obj_7netCD
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1830
+/* "netCDF4/_netCDF4.pyx":1840
*
* # these allow Dataset objects to be used via a "with" statement.
* def __enter__(self): # <<<<<<<<<<<<<<
@@ -12462,7 +12606,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_2__enter__(struct __pyx_ob
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__enter__", 0);
- /* "netCDF4/_netCDF4.pyx":1831
+ /* "netCDF4/_netCDF4.pyx":1841
* # these allow Dataset objects to be used via a "with" statement.
* def __enter__(self):
* return self # <<<<<<<<<<<<<<
@@ -12474,7 +12618,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_2__enter__(struct __pyx_ob
__pyx_r = ((PyObject *)__pyx_v_self);
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1830
+ /* "netCDF4/_netCDF4.pyx":1840
*
* # these allow Dataset objects to be used via a "with" statement.
* def __enter__(self): # <<<<<<<<<<<<<<
@@ -12489,7 +12633,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_2__enter__(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1832
+/* "netCDF4/_netCDF4.pyx":1842
* def __enter__(self):
* return self
* def __exit__(self,atype,value,traceback): # <<<<<<<<<<<<<<
@@ -12503,9 +12647,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_5__exit__(PyObject *__pyx_
CYTHON_UNUSED PyObject *__pyx_v_atype = 0;
CYTHON_UNUSED PyObject *__pyx_v_value = 0;
CYTHON_UNUSED PyObject *__pyx_v_traceback = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__exit__ (wrapper)", 0);
@@ -12530,16 +12671,16 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_5__exit__(PyObject *__pyx_
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1832; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 1); __PYX_ERR(0, 1842, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_traceback)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1832; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, 2); __PYX_ERR(0, 1842, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__exit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1832; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__exit__") < 0)) __PYX_ERR(0, 1842, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
@@ -12554,7 +12695,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_5__exit__(PyObject *__pyx_
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1832; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__exit__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1842, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.__exit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -12573,19 +12714,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_4__exit__(struct __pyx_obj
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__exit__", 0);
- /* "netCDF4/_netCDF4.pyx":1833
+ /* "netCDF4/_netCDF4.pyx":1843
* return self
* def __exit__(self,atype,value,traceback):
* self.close() # <<<<<<<<<<<<<<
*
* def __getitem__(self, elem):
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_close); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1833; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1843, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -12598,16 +12736,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_4__exit__(struct __pyx_obj
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1833; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1843, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1833; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1843, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1832
+ /* "netCDF4/_netCDF4.pyx":1842
* def __enter__(self):
* return self
* def __exit__(self,atype,value,traceback): # <<<<<<<<<<<<<<
@@ -12630,7 +12768,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_4__exit__(struct __pyx_obj
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1835
+/* "netCDF4/_netCDF4.pyx":1845
* self.close()
*
* def __getitem__(self, elem): # <<<<<<<<<<<<<<
@@ -12668,22 +12806,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
PyObject *(*__pyx_t_7)(PyObject *);
int __pyx_t_8;
int __pyx_t_9;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getitem__", 0);
__Pyx_INCREF(__pyx_v_elem);
- /* "netCDF4/_netCDF4.pyx":1838
+ /* "netCDF4/_netCDF4.pyx":1848
* # return variable or group defined in relative path.
* # split out group names in unix path.
* elem = posixpath.normpath(elem) # <<<<<<<<<<<<<<
* # last name in path, could be a variable or group
* dirname, lastname = posixpath.split(elem)
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1848, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_normpath); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_normpath); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1848, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -12697,16 +12832,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
}
}
if (!__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_elem); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_elem); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1848, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1848, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_elem);
__Pyx_GIVEREF(__pyx_v_elem);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_elem);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1848, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -12714,16 +12849,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__Pyx_DECREF_SET(__pyx_v_elem, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1840
+ /* "netCDF4/_netCDF4.pyx":1850
* elem = posixpath.normpath(elem)
* # last name in path, could be a variable or group
* dirname, lastname = posixpath.split(elem) # <<<<<<<<<<<<<<
* nestedgroups = dirname.split('/')
* group = self
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1850, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1850, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -12737,16 +12872,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_elem); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_elem); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1850, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1850, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_elem);
__Pyx_GIVEREF(__pyx_v_elem);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_elem);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1850, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -12761,7 +12896,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1850, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -12774,15 +12909,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_2);
#else
- __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1850, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1850, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1850, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext;
@@ -12790,7 +12925,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__Pyx_GOTREF(__pyx_t_4);
index = 1; __pyx_t_2 = __pyx_t_5(__pyx_t_3); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
__Pyx_GOTREF(__pyx_t_2);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_3), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_3), 2) < 0) __PYX_ERR(0, 1850, __pyx_L1_error)
__pyx_t_5 = NULL;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L4_unpacking_done;
@@ -12798,7 +12933,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_5 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1850, __pyx_L1_error)
__pyx_L4_unpacking_done:;
}
__pyx_v_dirname = __pyx_t_4;
@@ -12806,22 +12941,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__pyx_v_lastname = __pyx_t_2;
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1841
+ /* "netCDF4/_netCDF4.pyx":1851
* # last name in path, could be a variable or group
* dirname, lastname = posixpath.split(elem)
* nestedgroups = dirname.split('/') # <<<<<<<<<<<<<<
* group = self
* # iterate over groups in path.
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dirname, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1841; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dirname, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1851, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1841; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1851, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_nestedgroups = __pyx_t_2;
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1842
+ /* "netCDF4/_netCDF4.pyx":1852
* dirname, lastname = posixpath.split(elem)
* nestedgroups = dirname.split('/')
* group = self # <<<<<<<<<<<<<<
@@ -12831,7 +12966,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__pyx_v_group = ((PyObject *)__pyx_v_self);
- /* "netCDF4/_netCDF4.pyx":1844
+ /* "netCDF4/_netCDF4.pyx":1854
* group = self
* # iterate over groups in path.
* for g in nestedgroups: # <<<<<<<<<<<<<<
@@ -12842,26 +12977,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__pyx_t_2 = __pyx_v_nestedgroups; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_nestedgroups); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_nestedgroups); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1854, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1854, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_7)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 1854, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1854, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 1854, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1854, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -12871,7 +13006,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 1854, __pyx_L1_error)
}
break;
}
@@ -12880,25 +13015,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__Pyx_XDECREF_SET(__pyx_v_g, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1845
+ /* "netCDF4/_netCDF4.pyx":1855
* # iterate over groups in path.
* for g in nestedgroups:
* if g: group = group.groups[g] # <<<<<<<<<<<<<<
* # return last one, either a group or a variable.
* if lastname in group.groups:
*/
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_g); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1845; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_g); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1855, __pyx_L1_error)
if (__pyx_t_8) {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1845; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1855, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyObject_GetItem(__pyx_t_1, __pyx_v_g); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1845; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_t_1, __pyx_v_g); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1855, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_group, __pyx_t_4);
__pyx_t_4 = 0;
}
- /* "netCDF4/_netCDF4.pyx":1844
+ /* "netCDF4/_netCDF4.pyx":1854
* group = self
* # iterate over groups in path.
* for g in nestedgroups: # <<<<<<<<<<<<<<
@@ -12908,21 +13043,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1847
+ /* "netCDF4/_netCDF4.pyx":1857
* if g: group = group.groups[g]
* # return last one, either a group or a variable.
* if lastname in group.groups: # <<<<<<<<<<<<<<
* return group.groups[lastname]
* elif lastname in group.variables:
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1847; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1857, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_lastname, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1847; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_lastname, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1857, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_9 = (__pyx_t_8 != 0);
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":1848
+ /* "netCDF4/_netCDF4.pyx":1858
* # return last one, either a group or a variable.
* if lastname in group.groups:
* return group.groups[lastname] # <<<<<<<<<<<<<<
@@ -12930,16 +13065,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
* return group.variables[lastname]
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1848; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1858, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = PyObject_GetItem(__pyx_t_2, __pyx_v_lastname); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1848; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_t_2, __pyx_v_lastname); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1858, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1847
+ /* "netCDF4/_netCDF4.pyx":1857
* if g: group = group.groups[g]
* # return last one, either a group or a variable.
* if lastname in group.groups: # <<<<<<<<<<<<<<
@@ -12948,21 +13083,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
*/
}
- /* "netCDF4/_netCDF4.pyx":1849
+ /* "netCDF4/_netCDF4.pyx":1859
* if lastname in group.groups:
* return group.groups[lastname]
* elif lastname in group.variables: # <<<<<<<<<<<<<<
* return group.variables[lastname]
* else:
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1849; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1859, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_v_lastname, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1849; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = (__Pyx_PySequence_ContainsTF(__pyx_v_lastname, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1859, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_8 = (__pyx_t_9 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":1850
+ /* "netCDF4/_netCDF4.pyx":1860
* return group.groups[lastname]
* elif lastname in group.variables:
* return group.variables[lastname] # <<<<<<<<<<<<<<
@@ -12970,16 +13105,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
* raise IndexError('%s not found in %s' % (lastname,group.path))
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1850; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1860, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = PyObject_GetItem(__pyx_t_4, __pyx_v_lastname); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1850; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_t_4, __pyx_v_lastname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1860, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1849
+ /* "netCDF4/_netCDF4.pyx":1859
* if lastname in group.groups:
* return group.groups[lastname]
* elif lastname in group.variables: # <<<<<<<<<<<<<<
@@ -12988,7 +13123,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
*/
}
- /* "netCDF4/_netCDF4.pyx":1852
+ /* "netCDF4/_netCDF4.pyx":1862
* return group.variables[lastname]
* else:
* raise IndexError('%s not found in %s' % (lastname,group.path)) # <<<<<<<<<<<<<<
@@ -12996,9 +13131,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
* def filepath(self):
*/
/*else*/ {
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_lastname);
__Pyx_GIVEREF(__pyx_v_lastname);
@@ -13006,23 +13141,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_s_not_found_in_s, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_s_not_found_in_s, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1862, __pyx_L1_error)
}
- /* "netCDF4/_netCDF4.pyx":1835
+ /* "netCDF4/_netCDF4.pyx":1845
* self.close()
*
* def __getitem__(self, elem): # <<<<<<<<<<<<<<
@@ -13050,7 +13185,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6__getitem__(struct __pyx_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1854
+/* "netCDF4/_netCDF4.pyx":1864
* raise IndexError('%s not found in %s' % (lastname,group.path))
*
* def filepath(self): # <<<<<<<<<<<<<<
@@ -13078,12 +13213,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_8filepath(CYTHON_UNUSED st
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("filepath", 0);
- /* "netCDF4/_netCDF4.pyx":1881
+ /* "netCDF4/_netCDF4.pyx":1891
* return py_path.decode('ascii')
* ELSE:
* msg = """ # <<<<<<<<<<<<<<
@@ -13093,26 +13225,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_8filepath(CYTHON_UNUSED st
__Pyx_INCREF(__pyx_kp_s_filepath_method_not_enabled_To);
__pyx_v_msg = __pyx_kp_s_filepath_method_not_enabled_To;
- /* "netCDF4/_netCDF4.pyx":1884
+ /* "netCDF4/_netCDF4.pyx":1894
* filepath method not enabled. To enable, install Cython, make sure you have
* version 4.1.2 or higher of the netcdf C lib, and rebuild netcdf4-python."""
* raise ValueError(msg) # <<<<<<<<<<<<<<
*
* def __repr__(self):
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1884; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1894, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1884; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1894, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1884; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1894, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1854
+ /* "netCDF4/_netCDF4.pyx":1864
* raise IndexError('%s not found in %s' % (lastname,group.path))
*
* def filepath(self): # <<<<<<<<<<<<<<
@@ -13132,7 +13264,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_8filepath(CYTHON_UNUSED st
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1886
+/* "netCDF4/_netCDF4.pyx":1896
* raise ValueError(msg)
*
* def __repr__(self): # <<<<<<<<<<<<<<
@@ -13162,25 +13294,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
- /* "netCDF4/_netCDF4.pyx":1887
+ /* "netCDF4/_netCDF4.pyx":1897
*
* def __repr__(self):
* if python3: # <<<<<<<<<<<<<<
* return self.__unicode__()
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1887; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1897, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1887; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1897, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":1888
+ /* "netCDF4/_netCDF4.pyx":1898
* def __repr__(self):
* if python3:
* return self.__unicode__() # <<<<<<<<<<<<<<
@@ -13188,7 +13317,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
* return unicode(self).encode(default_encoding)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1888; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1898, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -13201,10 +13330,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1888; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1898, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1888; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1898, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -13212,7 +13341,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1887
+ /* "netCDF4/_netCDF4.pyx":1897
*
* def __repr__(self):
* if python3: # <<<<<<<<<<<<<<
@@ -13221,7 +13350,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":1890
+ /* "netCDF4/_netCDF4.pyx":1900
* return self.__unicode__()
* else:
* return unicode(self).encode(default_encoding) # <<<<<<<<<<<<<<
@@ -13230,18 +13359,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1900, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1900, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1900, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1900, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -13254,17 +13383,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1900, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1900, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1900, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -13274,7 +13403,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":1886
+ /* "netCDF4/_netCDF4.pyx":1896
* raise ValueError(msg)
*
* def __repr__(self): # <<<<<<<<<<<<<<
@@ -13297,7 +13426,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_10__repr__(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1892
+/* "netCDF4/_netCDF4.pyx":1902
* return unicode(self).encode(default_encoding)
*
* def __unicode__(self): # <<<<<<<<<<<<<<
@@ -13343,21 +13472,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
PyObject *__pyx_t_11 = NULL;
int __pyx_t_12;
int __pyx_t_13;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__unicode__", 0);
- /* "netCDF4/_netCDF4.pyx":1893
+ /* "netCDF4/_netCDF4.pyx":1903
*
* def __unicode__(self):
* ncdump = ['%r\n' % type(self)] # <<<<<<<<<<<<<<
* dimnames = tuple([_tostr(dimname)+'(%s)'%len(self.dimensions[dimname])\
* for dimname in self.dimensions.keys()])
*/
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_r_3, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_r_3, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1903, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1903, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_1);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
@@ -13365,24 +13491,24 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__pyx_v_ncdump = ((PyObject*)__pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1894
+ /* "netCDF4/_netCDF4.pyx":1904
* def __unicode__(self):
* ncdump = ['%r\n' % type(self)]
* dimnames = tuple([_tostr(dimname)+'(%s)'%len(self.dimensions[dimname])\ # <<<<<<<<<<<<<<
* for dimname in self.dimensions.keys()])
* varnames = tuple(\
*/
- __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- /* "netCDF4/_netCDF4.pyx":1895
+ /* "netCDF4/_netCDF4.pyx":1905
* ncdump = ['%r\n' % type(self)]
* dimnames = tuple([_tostr(dimname)+'(%s)'%len(self.dimensions[dimname])\
* for dimname in self.dimensions.keys()]) # <<<<<<<<<<<<<<
* varnames = tuple(\
* [_tostr(self.variables[varname].dtype)+' \033[4m'+_tostr(varname)+'\033[0m'+
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dimensions, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dimensions, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1905, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -13395,10 +13521,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1905, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1905, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -13406,9 +13532,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1905, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1905, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -13416,17 +13542,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1905, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1905, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1905, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1905, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -13436,7 +13562,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 1905, __pyx_L1_error)
}
break;
}
@@ -13445,14 +13571,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1894
+ /* "netCDF4/_netCDF4.pyx":1904
* def __unicode__(self):
* ncdump = ['%r\n' % type(self)]
* dimnames = tuple([_tostr(dimname)+'(%s)'%len(self.dimensions[dimname])\ # <<<<<<<<<<<<<<
* for dimname in self.dimensions.keys()])
* varnames = tuple(\
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
@@ -13465,37 +13591,37 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (!__pyx_t_7) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_dimname); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_dimname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_dimname);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyObject_GetItem(__pyx_v_self->dimensions, __pyx_v_dimname); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_self->dimensions, __pyx_v_dimname); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_9 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s, __pyx_t_4); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Add(__pyx_t_1, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":1895
+ /* "netCDF4/_netCDF4.pyx":1905
* ncdump = ['%r\n' % type(self)]
* dimnames = tuple([_tostr(dimname)+'(%s)'%len(self.dimensions[dimname])\
* for dimname in self.dimensions.keys()]) # <<<<<<<<<<<<<<
@@ -13505,37 +13631,37 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":1894
+ /* "netCDF4/_netCDF4.pyx":1904
* def __unicode__(self):
* ncdump = ['%r\n' % type(self)]
* dimnames = tuple([_tostr(dimname)+'(%s)'%len(self.dimensions[dimname])\ # <<<<<<<<<<<<<<
* for dimname in self.dimensions.keys()])
* varnames = tuple(\
*/
- __pyx_t_3 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_dimnames = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":1897
+ /* "netCDF4/_netCDF4.pyx":1907
* for dimname in self.dimensions.keys()])
* varnames = tuple(\
* [_tostr(self.variables[varname].dtype)+' \033[4m'+_tostr(varname)+'\033[0m'+ # <<<<<<<<<<<<<<
* (((_tostr(self.variables[varname].dimensions)
* .replace("u'",""))\
*/
- __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- /* "netCDF4/_netCDF4.pyx":1902
+ /* "netCDF4/_netCDF4.pyx":1912
* .replace("'",""))\
* .replace(", ",","))\
* .replace(",)",")") for varname in self.variables.keys()]) # <<<<<<<<<<<<<<
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()])
* if self.path == '/':
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_keys); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_keys); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_8 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -13548,10 +13674,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (__pyx_t_8) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1912, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1912, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -13559,9 +13685,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1912, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -13569,17 +13695,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1912, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1912, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -13589,7 +13715,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 1912, __pyx_L1_error)
}
break;
}
@@ -13598,18 +13724,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__Pyx_XDECREF_SET(__pyx_v_varname, __pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1897
+ /* "netCDF4/_netCDF4.pyx":1907
* for dimname in self.dimensions.keys()])
* varnames = tuple(\
* [_tostr(self.variables[varname].dtype)+' \033[4m'+_tostr(varname)+'\033[0m'+ # <<<<<<<<<<<<<<
* (((_tostr(self.variables[varname].dimensions)
* .replace("u'",""))\
*/
- __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_1 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_varname); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_varname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -13623,25 +13749,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (!__pyx_t_1) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_7);
__pyx_t_7 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = PyNumber_Add(__pyx_t_2, __pyx_kp_s_4m); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyNumber_Add(__pyx_t_2, __pyx_kp_s_4m); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_10))) {
@@ -13654,40 +13780,40 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (!__pyx_t_7) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_varname); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_varname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_INCREF(__pyx_v_varname);
__Pyx_GIVEREF(__pyx_v_varname);
PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_v_varname);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = PyNumber_Add(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyNumber_Add(__pyx_t_8, __pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Add(__pyx_t_10, __pyx_kp_s_0m); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Add(__pyx_t_10, __pyx_kp_s_0m); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":1898
+ /* "netCDF4/_netCDF4.pyx":1908
* varnames = tuple(\
* [_tostr(self.variables[varname].dtype)+' \033[4m'+_tostr(varname)+'\033[0m'+
* (((_tostr(self.variables[varname].dimensions) # <<<<<<<<<<<<<<
* .replace("u'",""))\
* .replace("'",""))\
*/
- __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1898; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1908, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_1 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_varname); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1898; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_varname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1908, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1898; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1908, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -13701,93 +13827,93 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (!__pyx_t_1) {
- __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1898; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1908, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_10);
} else {
- __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1898; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1908, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_7);
__pyx_t_7 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1898; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1908, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1899
+ /* "netCDF4/_netCDF4.pyx":1909
* [_tostr(self.variables[varname].dtype)+' \033[4m'+_tostr(varname)+'\033[0m'+
* (((_tostr(self.variables[varname].dimensions)
* .replace("u'",""))\ # <<<<<<<<<<<<<<
* .replace("'",""))\
* .replace(", ",","))\
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_replace); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_replace); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1909, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1909, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1900
+ /* "netCDF4/_netCDF4.pyx":1910
* (((_tostr(self.variables[varname].dimensions)
* .replace("u'",""))\
* .replace("'",""))\ # <<<<<<<<<<<<<<
* .replace(", ",","))\
* .replace(",)",")") for varname in self.variables.keys()])
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_replace); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1900; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_replace); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1900; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1901
+ /* "netCDF4/_netCDF4.pyx":1911
* .replace("u'",""))\
* .replace("'",""))\
* .replace(", ",","))\ # <<<<<<<<<<<<<<
* .replace(",)",")") for varname in self.variables.keys()])
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()])
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_replace); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1901; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_replace); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1901; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1902
+ /* "netCDF4/_netCDF4.pyx":1912
* .replace("'",""))\
* .replace(", ",","))\
* .replace(",)",")") for varname in self.variables.keys()]) # <<<<<<<<<<<<<<
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()])
* if self.path == '/':
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_replace); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_replace); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1897
+ /* "netCDF4/_netCDF4.pyx":1907
* for dimname in self.dimensions.keys()])
* varnames = tuple(\
* [_tostr(self.variables[varname].dtype)+' \033[4m'+_tostr(varname)+'\033[0m'+ # <<<<<<<<<<<<<<
* (((_tostr(self.variables[varname].dimensions)
* .replace("u'",""))\
*/
- __pyx_t_8 = PyNumber_Add(__pyx_t_2, __pyx_t_10); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyNumber_Add(__pyx_t_2, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_8))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 1907, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1902
+ /* "netCDF4/_netCDF4.pyx":1912
* .replace("'",""))\
* .replace(", ",","))\
* .replace(",)",")") for varname in self.variables.keys()]) # <<<<<<<<<<<<<<
@@ -13797,29 +13923,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":1896
+ /* "netCDF4/_netCDF4.pyx":1906
* dimnames = tuple([_tostr(dimname)+'(%s)'%len(self.dimensions[dimname])\
* for dimname in self.dimensions.keys()])
* varnames = tuple(\ # <<<<<<<<<<<<<<
* [_tostr(self.variables[varname].dtype)+' \033[4m'+_tostr(varname)+'\033[0m'+
* (((_tostr(self.variables[varname].dimensions)
*/
- __pyx_t_4 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1896; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1906, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_varnames = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":1903
+ /* "netCDF4/_netCDF4.pyx":1913
* .replace(", ",","))\
* .replace(",)",")") for varname in self.variables.keys()])
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()]) # <<<<<<<<<<<<<<
* if self.path == '/':
* ncdump.append('root group (%s data model, file format %s):\n' %
*/
- __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->groups, __pyx_n_s_keys); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->groups, __pyx_n_s_keys); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_10 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_8))) {
@@ -13832,10 +13958,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (__pyx_t_10) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1913, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
@@ -13843,9 +13969,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__pyx_t_8 = __pyx_t_3; __Pyx_INCREF(__pyx_t_8); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_6 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1913, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
for (;;) {
@@ -13853,17 +13979,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
if (likely(PyList_CheckExact(__pyx_t_8))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_8)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1913, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_8)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1913, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_8, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
}
@@ -13873,7 +13999,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 1913, __pyx_L1_error)
}
break;
}
@@ -13881,7 +14007,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
__Pyx_XDECREF_SET(__pyx_v_grpname, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_2 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_10))) {
@@ -13894,48 +14020,48 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (!__pyx_t_2) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_grpname); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_grpname); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_grpname);
__Pyx_GIVEREF(__pyx_v_grpname);
PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_v_grpname);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_3))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = PyList_AsTuple(((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyList_AsTuple(((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1913, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_grpnames = ((PyObject*)__pyx_t_8);
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1904
+ /* "netCDF4/_netCDF4.pyx":1914
* .replace(",)",")") for varname in self.variables.keys()])
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()])
* if self.path == '/': # <<<<<<<<<<<<<<
* ncdump.append('root group (%s data model, file format %s):\n' %
* (self.data_model, self.disk_format))
*/
- __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_v_self->path, __pyx_kp_s__16, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1904; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_v_self->path, __pyx_kp_s__16, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 1914, __pyx_L1_error)
if (__pyx_t_12) {
- /* "netCDF4/_netCDF4.pyx":1906
+ /* "netCDF4/_netCDF4.pyx":1916
* if self.path == '/':
* ncdump.append('root group (%s data model, file format %s):\n' %
* (self.data_model, self.disk_format)) # <<<<<<<<<<<<<<
* else:
* ncdump.append('group %s:\n' % self.path)
*/
- __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1906; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1916, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_v_self->data_model);
__Pyx_GIVEREF(__pyx_v_self->data_model);
@@ -13944,20 +14070,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__Pyx_GIVEREF(__pyx_v_self->disk_format);
PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_self->disk_format);
- /* "netCDF4/_netCDF4.pyx":1905
+ /* "netCDF4/_netCDF4.pyx":1915
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()])
* if self.path == '/':
* ncdump.append('root group (%s data model, file format %s):\n' % # <<<<<<<<<<<<<<
* (self.data_model, self.disk_format))
* else:
*/
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_root_group_s_data_model_file_for, __pyx_t_8); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1905; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_root_group_s_data_model_file_for, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1915, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_4); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1905; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_4); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 1915, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":1904
+ /* "netCDF4/_netCDF4.pyx":1914
* .replace(",)",")") for varname in self.variables.keys()])
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()])
* if self.path == '/': # <<<<<<<<<<<<<<
@@ -13967,7 +14093,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":1908
+ /* "netCDF4/_netCDF4.pyx":1918
* (self.data_model, self.disk_format))
* else:
* ncdump.append('group %s:\n' % self.path) # <<<<<<<<<<<<<<
@@ -13975,31 +14101,31 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
* self.ncattrs()]
*/
/*else*/ {
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_group_s, __pyx_v_self->path); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1908; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_group_s, __pyx_v_self->path); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1918, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_4); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1908; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_4); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 1918, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
__pyx_L9:;
- /* "netCDF4/_netCDF4.pyx":1909
+ /* "netCDF4/_netCDF4.pyx":1919
* else:
* ncdump.append('group %s:\n' % self.path)
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\ # <<<<<<<<<<<<<<
* self.ncattrs()]
* ncdump = ncdump + attrs
*/
- __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- /* "netCDF4/_netCDF4.pyx":1910
+ /* "netCDF4/_netCDF4.pyx":1920
* ncdump.append('group %s:\n' % self.path)
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\
* self.ncattrs()] # <<<<<<<<<<<<<<
* ncdump = ncdump + attrs
* ncdump.append(' dimensions(sizes): %s\n' % ', '.join(dimnames))
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1920, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_10 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -14012,10 +14138,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (__pyx_t_10) {
- __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1920, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
- __pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1920, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -14023,9 +14149,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__pyx_t_3 = __pyx_t_8; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1920, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1920, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
for (;;) {
@@ -14033,17 +14159,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_8 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_8); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_8); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1920, __pyx_L1_error)
#else
- __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1920, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_8); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_8); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 1920, __pyx_L1_error)
#else
- __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1920, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
}
@@ -14053,7 +14179,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1910; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 1920, __pyx_L1_error)
}
break;
}
@@ -14062,14 +14188,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_8);
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":1909
+ /* "netCDF4/_netCDF4.pyx":1919
* else:
* ncdump.append('group %s:\n' % self.path)
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\ # <<<<<<<<<<<<<<
* self.ncattrs()]
* ncdump = ncdump + attrs
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getncattr); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getncattr); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_11 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_10))) {
@@ -14082,21 +14208,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
}
}
if (!__pyx_t_11) {
- __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_name); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_11); __pyx_t_11 = NULL;
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_name);
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_2, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_2, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 1919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
@@ -14104,74 +14230,74 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_8);
__pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_10); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_8))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 1919, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_attrs = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":1911
+ /* "netCDF4/_netCDF4.pyx":1921
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\
* self.ncattrs()]
* ncdump = ncdump + attrs # <<<<<<<<<<<<<<
* ncdump.append(' dimensions(sizes): %s\n' % ', '.join(dimnames))
* ncdump.append(' variables(dimensions): %s\n' % ', '.join(varnames))
*/
- __pyx_t_4 = PyNumber_Add(__pyx_v_ncdump, __pyx_v_attrs); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1911; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Add(__pyx_v_ncdump, __pyx_v_attrs); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1921, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF_SET(__pyx_v_ncdump, ((PyObject*)__pyx_t_4));
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":1912
+ /* "netCDF4/_netCDF4.pyx":1922
* self.ncattrs()]
* ncdump = ncdump + attrs
* ncdump.append(' dimensions(sizes): %s\n' % ', '.join(dimnames)) # <<<<<<<<<<<<<<
* ncdump.append(' variables(dimensions): %s\n' % ', '.join(varnames))
* ncdump.append(' groups: %s\n' % ', '.join(grpnames))
*/
- __pyx_t_4 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1912; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_dimensions_sizes_s, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1912; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_dimensions_sizes_s, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1912; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 1922, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":1913
+ /* "netCDF4/_netCDF4.pyx":1923
* ncdump = ncdump + attrs
* ncdump.append(' dimensions(sizes): %s\n' % ', '.join(dimnames))
* ncdump.append(' variables(dimensions): %s\n' % ', '.join(varnames)) # <<<<<<<<<<<<<<
* ncdump.append(' groups: %s\n' % ', '.join(grpnames))
* return ''.join(ncdump)
*/
- __pyx_t_3 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_varnames); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1913; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_varnames); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1923, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_variables_dimensions_s, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1913; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_variables_dimensions_s, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1923, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_4); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1913; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_4); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 1923, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":1914
+ /* "netCDF4/_netCDF4.pyx":1924
* ncdump.append(' dimensions(sizes): %s\n' % ', '.join(dimnames))
* ncdump.append(' variables(dimensions): %s\n' % ', '.join(varnames))
* ncdump.append(' groups: %s\n' % ', '.join(grpnames)) # <<<<<<<<<<<<<<
* return ''.join(ncdump)
*
*/
- __pyx_t_4 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_grpnames); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1914; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_grpnames); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1924, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_groups_s, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1914; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_groups_s, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1924, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1914; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_3); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 1924, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":1915
+ /* "netCDF4/_netCDF4.pyx":1925
* ncdump.append(' variables(dimensions): %s\n' % ', '.join(varnames))
* ncdump.append(' groups: %s\n' % ', '.join(grpnames))
* return ''.join(ncdump) # <<<<<<<<<<<<<<
@@ -14179,13 +14305,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
* def close(self):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_v_ncdump); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1915; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_v_ncdump); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1925, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1892
+ /* "netCDF4/_netCDF4.pyx":1902
* return unicode(self).encode(default_encoding)
*
* def __unicode__(self): # <<<<<<<<<<<<<<
@@ -14220,7 +14346,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_12__unicode__(struct __pyx
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1917
+/* "netCDF4/_netCDF4.pyx":1927
* return ''.join(ncdump)
*
* def close(self): # <<<<<<<<<<<<<<
@@ -14250,12 +14376,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_14close(struct __pyx_obj_7
char *__pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("close", 0);
- /* "netCDF4/_netCDF4.pyx":1924
+ /* "netCDF4/_netCDF4.pyx":1934
* """
* cdef int ierr
* ierr = nc_close(self._grpid) # <<<<<<<<<<<<<<
@@ -14264,7 +14387,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_14close(struct __pyx_obj_7
*/
__pyx_v_ierr = nc_close(__pyx_v_self->_grpid);
- /* "netCDF4/_netCDF4.pyx":1925
+ /* "netCDF4/_netCDF4.pyx":1935
* cdef int ierr
* ierr = nc_close(self._grpid)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -14274,7 +14397,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_14close(struct __pyx_obj_7
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1926
+ /* "netCDF4/_netCDF4.pyx":1936
* ierr = nc_close(self._grpid)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -14282,22 +14405,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_14close(struct __pyx_obj_7
*
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1936, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1936, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1936, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1936, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1925
+ /* "netCDF4/_netCDF4.pyx":1935
* cdef int ierr
* ierr = nc_close(self._grpid)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -14306,7 +14429,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_14close(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":1927
+ /* "netCDF4/_netCDF4.pyx":1937
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* self._isopen = 0 # indicates file already closed, checked by __dealloc__ # <<<<<<<<<<<<<<
@@ -14315,7 +14438,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_14close(struct __pyx_obj_7
*/
__pyx_v_self->_isopen = 0;
- /* "netCDF4/_netCDF4.pyx":1917
+ /* "netCDF4/_netCDF4.pyx":1927
* return ''.join(ncdump)
*
* def close(self): # <<<<<<<<<<<<<<
@@ -14337,7 +14460,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_14close(struct __pyx_obj_7
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1929
+/* "netCDF4/_netCDF4.pyx":1939
* self._isopen = 0 # indicates file already closed, checked by __dealloc__
*
* def isopen(self): # <<<<<<<<<<<<<<
@@ -14364,12 +14487,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_16isopen(struct __pyx_obj_
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("isopen", 0);
- /* "netCDF4/_netCDF4.pyx":1935
+ /* "netCDF4/_netCDF4.pyx":1945
* is the Dataset open or closed?
* """
* return bool(self._isopen) # <<<<<<<<<<<<<<
@@ -14377,17 +14497,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_16isopen(struct __pyx_obj_
* def __dealloc__(self):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_isopen); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1935; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_isopen); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1935; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1945, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1935; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyBool_FromLong((!(!__pyx_t_2))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1929
+ /* "netCDF4/_netCDF4.pyx":1939
* self._isopen = 0 # indicates file already closed, checked by __dealloc__
*
* def isopen(self): # <<<<<<<<<<<<<<
@@ -14406,7 +14526,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_16isopen(struct __pyx_obj_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1937
+/* "netCDF4/_netCDF4.pyx":1947
* return bool(self._isopen)
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
@@ -14431,7 +14551,7 @@ static void __pyx_pf_7netCDF4_8_netCDF4_7Dataset_18__dealloc__(struct __pyx_obj_
int __pyx_t_1;
__Pyx_RefNannySetupContext("__dealloc__", 0);
- /* "netCDF4/_netCDF4.pyx":1940
+ /* "netCDF4/_netCDF4.pyx":1950
* # close file when there are no references to object left
* cdef int ierr
* if self._isopen: # <<<<<<<<<<<<<<
@@ -14441,7 +14561,7 @@ static void __pyx_pf_7netCDF4_8_netCDF4_7Dataset_18__dealloc__(struct __pyx_obj_
__pyx_t_1 = (__pyx_v_self->_isopen != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1941
+ /* "netCDF4/_netCDF4.pyx":1951
* cdef int ierr
* if self._isopen:
* ierr = nc_close(self._grpid) # <<<<<<<<<<<<<<
@@ -14450,7 +14570,7 @@ static void __pyx_pf_7netCDF4_8_netCDF4_7Dataset_18__dealloc__(struct __pyx_obj_
*/
__pyx_v_ierr = nc_close(__pyx_v_self->_grpid);
- /* "netCDF4/_netCDF4.pyx":1940
+ /* "netCDF4/_netCDF4.pyx":1950
* # close file when there are no references to object left
* cdef int ierr
* if self._isopen: # <<<<<<<<<<<<<<
@@ -14459,7 +14579,7 @@ static void __pyx_pf_7netCDF4_8_netCDF4_7Dataset_18__dealloc__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":1937
+ /* "netCDF4/_netCDF4.pyx":1947
* return bool(self._isopen)
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
@@ -14471,7 +14591,7 @@ static void __pyx_pf_7netCDF4_8_netCDF4_7Dataset_18__dealloc__(struct __pyx_obj_
__Pyx_RefNannyFinishContext();
}
-/* "netCDF4/_netCDF4.pyx":1943
+/* "netCDF4/_netCDF4.pyx":1953
* ierr = nc_close(self._grpid)
*
* def sync(self): # <<<<<<<<<<<<<<
@@ -14501,12 +14621,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_20sync(struct __pyx_obj_7n
char *__pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("sync", 0);
- /* "netCDF4/_netCDF4.pyx":1949
+ /* "netCDF4/_netCDF4.pyx":1959
* Writes all buffered data in the `netCDF4.Dataset` to the disk file."""
* cdef int ierr
* ierr = nc_sync(self._grpid) # <<<<<<<<<<<<<<
@@ -14515,7 +14632,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_20sync(struct __pyx_obj_7n
*/
__pyx_v_ierr = nc_sync(__pyx_v_self->_grpid);
- /* "netCDF4/_netCDF4.pyx":1950
+ /* "netCDF4/_netCDF4.pyx":1960
* cdef int ierr
* ierr = nc_sync(self._grpid)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -14525,7 +14642,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_20sync(struct __pyx_obj_7n
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1951
+ /* "netCDF4/_netCDF4.pyx":1961
* ierr = nc_sync(self._grpid)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -14533,22 +14650,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_20sync(struct __pyx_obj_7n
* def _redef(self):
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1961, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1950
+ /* "netCDF4/_netCDF4.pyx":1960
* cdef int ierr
* ierr = nc_sync(self._grpid)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -14557,7 +14674,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_20sync(struct __pyx_obj_7n
*/
}
- /* "netCDF4/_netCDF4.pyx":1943
+ /* "netCDF4/_netCDF4.pyx":1953
* ierr = nc_close(self._grpid)
*
* def sync(self): # <<<<<<<<<<<<<<
@@ -14579,7 +14696,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_20sync(struct __pyx_obj_7n
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1953
+/* "netCDF4/_netCDF4.pyx":1963
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def _redef(self): # <<<<<<<<<<<<<<
@@ -14606,7 +14723,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_22_redef(struct __pyx_obj_
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_redef", 0);
- /* "netCDF4/_netCDF4.pyx":1955
+ /* "netCDF4/_netCDF4.pyx":1965
* def _redef(self):
* cdef int ierr
* ierr = nc_redef(self._grpid) # <<<<<<<<<<<<<<
@@ -14615,7 +14732,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_22_redef(struct __pyx_obj_
*/
__pyx_v_ierr = nc_redef(__pyx_v_self->_grpid);
- /* "netCDF4/_netCDF4.pyx":1953
+ /* "netCDF4/_netCDF4.pyx":1963
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def _redef(self): # <<<<<<<<<<<<<<
@@ -14630,7 +14747,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_22_redef(struct __pyx_obj_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1957
+/* "netCDF4/_netCDF4.pyx":1967
* ierr = nc_redef(self._grpid)
*
* def _enddef(self): # <<<<<<<<<<<<<<
@@ -14657,7 +14774,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_24_enddef(struct __pyx_obj
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_enddef", 0);
- /* "netCDF4/_netCDF4.pyx":1959
+ /* "netCDF4/_netCDF4.pyx":1969
* def _enddef(self):
* cdef int ierr
* ierr = nc_enddef(self._grpid) # <<<<<<<<<<<<<<
@@ -14666,7 +14783,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_24_enddef(struct __pyx_obj
*/
__pyx_v_ierr = nc_enddef(__pyx_v_self->_grpid);
- /* "netCDF4/_netCDF4.pyx":1957
+ /* "netCDF4/_netCDF4.pyx":1967
* ierr = nc_redef(self._grpid)
*
* def _enddef(self): # <<<<<<<<<<<<<<
@@ -14681,7 +14798,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_24_enddef(struct __pyx_obj
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1961
+/* "netCDF4/_netCDF4.pyx":1971
* ierr = nc_enddef(self._grpid)
*
* def set_fill_on(self): # <<<<<<<<<<<<<<
@@ -14712,12 +14829,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_26set_fill_on(struct __pyx
char *__pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_fill_on", 0);
- /* "netCDF4/_netCDF4.pyx":1975
+ /* "netCDF4/_netCDF4.pyx":1985
* to."""
* cdef int ierr, oldmode
* ierr = nc_set_fill (self._grpid, NC_FILL, &oldmode) # <<<<<<<<<<<<<<
@@ -14726,7 +14840,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_26set_fill_on(struct __pyx
*/
__pyx_v_ierr = nc_set_fill(__pyx_v_self->_grpid, NC_FILL, (&__pyx_v_oldmode));
- /* "netCDF4/_netCDF4.pyx":1976
+ /* "netCDF4/_netCDF4.pyx":1986
* cdef int ierr, oldmode
* ierr = nc_set_fill (self._grpid, NC_FILL, &oldmode)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -14736,7 +14850,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_26set_fill_on(struct __pyx
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1977
+ /* "netCDF4/_netCDF4.pyx":1987
* ierr = nc_set_fill (self._grpid, NC_FILL, &oldmode)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -14744,22 +14858,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_26set_fill_on(struct __pyx
* def set_fill_off(self):
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1987, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1976
+ /* "netCDF4/_netCDF4.pyx":1986
* cdef int ierr, oldmode
* ierr = nc_set_fill (self._grpid, NC_FILL, &oldmode)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -14768,7 +14882,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_26set_fill_on(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":1961
+ /* "netCDF4/_netCDF4.pyx":1971
* ierr = nc_enddef(self._grpid)
*
* def set_fill_on(self): # <<<<<<<<<<<<<<
@@ -14790,7 +14904,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_26set_fill_on(struct __pyx
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1979
+/* "netCDF4/_netCDF4.pyx":1989
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def set_fill_off(self): # <<<<<<<<<<<<<<
@@ -14821,12 +14935,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_28set_fill_off(struct __py
char *__pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_fill_off", 0);
- /* "netCDF4/_netCDF4.pyx":1989
+ /* "netCDF4/_netCDF4.pyx":1999
* sure the data is actually written before being read."""
* cdef int ierr, oldmode
* ierr = nc_set_fill (self._grpid, NC_NOFILL, &oldmode) # <<<<<<<<<<<<<<
@@ -14835,7 +14946,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_28set_fill_off(struct __py
*/
__pyx_v_ierr = nc_set_fill(__pyx_v_self->_grpid, NC_NOFILL, (&__pyx_v_oldmode));
- /* "netCDF4/_netCDF4.pyx":1990
+ /* "netCDF4/_netCDF4.pyx":2000
* cdef int ierr, oldmode
* ierr = nc_set_fill (self._grpid, NC_NOFILL, &oldmode)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -14845,7 +14956,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_28set_fill_off(struct __py
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":1991
+ /* "netCDF4/_netCDF4.pyx":2001
* ierr = nc_set_fill (self._grpid, NC_NOFILL, &oldmode)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -14853,22 +14964,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_28set_fill_off(struct __py
* def createDimension(self, dimname, size=None):
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2001, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2001, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2001, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2001, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1990
+ /* "netCDF4/_netCDF4.pyx":2000
* cdef int ierr, oldmode
* ierr = nc_set_fill (self._grpid, NC_NOFILL, &oldmode)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -14877,7 +14988,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_28set_fill_off(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":1979
+ /* "netCDF4/_netCDF4.pyx":1989
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def set_fill_off(self): # <<<<<<<<<<<<<<
@@ -14899,7 +15010,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_28set_fill_off(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1993
+/* "netCDF4/_netCDF4.pyx":2003
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def createDimension(self, dimname, size=None): # <<<<<<<<<<<<<<
@@ -14913,9 +15024,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_30createDimension[] = "\n**`cr
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_31createDimension(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_dimname = 0;
PyObject *__pyx_v_size = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("createDimension (wrapper)", 0);
@@ -14944,7 +15052,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_31createDimension(PyObject
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createDimension") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1993; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createDimension") < 0)) __PYX_ERR(0, 2003, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -14959,7 +15067,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_31createDimension(PyObject
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("createDimension", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1993; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createDimension", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2003, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.createDimension", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -14978,19 +15086,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_30createDimension(struct _
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("createDimension", 0);
- /* "netCDF4/_netCDF4.pyx":2006
+ /* "netCDF4/_netCDF4.pyx":2016
* instance. To determine if a dimension is 'unlimited', use the
* `netCDF4.Dimension.isunlimited` method of the `netCDF4.Dimension` instance."""
* self.dimensions[dimname] = Dimension(self, dimname, size=size) # <<<<<<<<<<<<<<
* return self.dimensions[dimname]
*
*/
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2006; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2016, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
@@ -14998,17 +15103,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_30createDimension(struct _
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_dimname);
- __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2006; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2016, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_v_size) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2006; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dimension), __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2006; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_size, __pyx_v_size) < 0) __PYX_ERR(0, 2016, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dimension), __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2016, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_self->dimensions, __pyx_v_dimname, __pyx_t_3) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2006; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_self->dimensions, __pyx_v_dimname, __pyx_t_3) < 0)) __PYX_ERR(0, 2016, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2007
+ /* "netCDF4/_netCDF4.pyx":2017
* `netCDF4.Dimension.isunlimited` method of the `netCDF4.Dimension` instance."""
* self.dimensions[dimname] = Dimension(self, dimname, size=size)
* return self.dimensions[dimname] # <<<<<<<<<<<<<<
@@ -15016,13 +15121,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_30createDimension(struct _
* def renameDimension(self, oldname, newname):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyObject_GetItem(__pyx_v_self->dimensions, __pyx_v_dimname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2007; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_v_self->dimensions, __pyx_v_dimname); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":1993
+ /* "netCDF4/_netCDF4.pyx":2003
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def createDimension(self, dimname, size=None): # <<<<<<<<<<<<<<
@@ -15043,7 +15148,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_30createDimension(struct _
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2009
+/* "netCDF4/_netCDF4.pyx":2019
* return self.dimensions[dimname]
*
* def renameDimension(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -15057,9 +15162,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_32renameDimension[] = "\n**`re
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_33renameDimension(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_oldname = 0;
PyObject *__pyx_v_newname = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("renameDimension (wrapper)", 0);
@@ -15083,11 +15185,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_33renameDimension(PyObject
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_newname)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("renameDimension", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2009; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameDimension", 1, 2, 2, 1); __PYX_ERR(0, 2019, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameDimension") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2009; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameDimension") < 0)) __PYX_ERR(0, 2019, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -15100,7 +15202,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_33renameDimension(PyObject
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("renameDimension", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2009; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameDimension", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2019, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.renameDimension", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -15131,43 +15233,40 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
int __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("renameDimension", 0);
- /* "netCDF4/_netCDF4.pyx":2015
+ /* "netCDF4/_netCDF4.pyx":2025
* rename a `netCDF4.Dimension` named `oldname` to `newname`."""
* cdef char *namstring
* bytestr = _strencode(newname) # <<<<<<<<<<<<<<
* namstring = bytestr
* if self.data_model != 'NETCDF4': self._redef()
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_newname, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2015; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_newname, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2025, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2016
+ /* "netCDF4/_netCDF4.pyx":2026
* cdef char *namstring
* bytestr = _strencode(newname)
* namstring = bytestr # <<<<<<<<<<<<<<
* if self.data_model != 'NETCDF4': self._redef()
* try:
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2016; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 2026, __pyx_L1_error)
__pyx_v_namstring = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":2017
+ /* "netCDF4/_netCDF4.pyx":2027
* bytestr = _strencode(newname)
* namstring = bytestr
* if self.data_model != 'NETCDF4': self._redef() # <<<<<<<<<<<<<<
* try:
* dim = self.dimensions[oldname]
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2017; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2027, __pyx_L1_error)
if (__pyx_t_3) {
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2017; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2027, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -15180,17 +15279,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2017; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2027, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2017; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2027, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2018
+ /* "netCDF4/_netCDF4.pyx":2028
* namstring = bytestr
* if self.data_model != 'NETCDF4': self._redef()
* try: # <<<<<<<<<<<<<<
@@ -15198,25 +15297,27 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":2019
+ /* "netCDF4/_netCDF4.pyx":2029
* if self.data_model != 'NETCDF4': self._redef()
* try:
* dim = self.dimensions[oldname] # <<<<<<<<<<<<<<
* except KeyError:
* raise KeyError('%s not a valid dimension name' % oldname)
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_self->dimensions, __pyx_v_oldname); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2019; __pyx_clineno = __LINE__; goto __pyx_L4_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_self->dimensions, __pyx_v_oldname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2029, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_dim = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2018
+ /* "netCDF4/_netCDF4.pyx":2028
* namstring = bytestr
* if self.data_model != 'NETCDF4': self._redef()
* try: # <<<<<<<<<<<<<<
@@ -15229,56 +15330,58 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2020
+ /* "netCDF4/_netCDF4.pyx":2030
* try:
* dim = self.dimensions[oldname]
* except KeyError: # <<<<<<<<<<<<<<
* raise KeyError('%s not a valid dimension name' % oldname)
* ierr = nc_rename_dim(self._grpid, dim._dimid, namstring)
*/
- __pyx_t_9 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_9) {
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.renameDimension", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2020; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(0, 2030, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_5);
- /* "netCDF4/_netCDF4.pyx":2021
+ /* "netCDF4/_netCDF4.pyx":2031
* dim = self.dimensions[oldname]
* except KeyError:
* raise KeyError('%s not a valid dimension name' % oldname) # <<<<<<<<<<<<<<
* ierr = nc_rename_dim(self._grpid, dim._dimid, namstring)
* if self.data_model != 'NETCDF4': self._enddef()
*/
- __pyx_t_10 = __Pyx_PyString_Format(__pyx_kp_s_s_not_a_valid_dimension_name, __pyx_v_oldname); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2021; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ __pyx_t_10 = __Pyx_PyString_Format(__pyx_kp_s_s_not_a_valid_dimension_name, __pyx_v_oldname); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2031, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2021; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2031, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10);
__pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2021; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_11, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2031, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2021; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ __PYX_ERR(0, 2031, __pyx_L6_except_error)
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
- /* "netCDF4/_netCDF4.pyx":2018
+ /* "netCDF4/_netCDF4.pyx":2028
* namstring = bytestr
* if self.data_model != 'NETCDF4': self._redef()
* try: # <<<<<<<<<<<<<<
* dim = self.dimensions[oldname]
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
@@ -15287,29 +15390,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
__pyx_L11_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":2022
+ /* "netCDF4/_netCDF4.pyx":2032
* except KeyError:
* raise KeyError('%s not a valid dimension name' % oldname)
* ierr = nc_rename_dim(self._grpid, dim._dimid, namstring) # <<<<<<<<<<<<<<
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR:
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_dimid); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2022; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_dimid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2032, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2022; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2032, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_ierr = nc_rename_dim(__pyx_v_self->_grpid, __pyx_t_9, __pyx_v_namstring);
- /* "netCDF4/_netCDF4.pyx":2023
+ /* "netCDF4/_netCDF4.pyx":2033
* raise KeyError('%s not a valid dimension name' % oldname)
* ierr = nc_rename_dim(self._grpid, dim._dimid, namstring)
* if self.data_model != 'NETCDF4': self._enddef() # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2033, __pyx_L1_error)
if (__pyx_t_3) {
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2033, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -15322,17 +15425,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
}
}
if (__pyx_t_1) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2033, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2033, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2024
+ /* "netCDF4/_netCDF4.pyx":2034
* ierr = nc_rename_dim(self._grpid, dim._dimid, namstring)
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -15342,7 +15445,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2025
+ /* "netCDF4/_netCDF4.pyx":2035
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -15350,22 +15453,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
* self.dimensions.pop(oldname)
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_5 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2035, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2024
+ /* "netCDF4/_netCDF4.pyx":2034
* ierr = nc_rename_dim(self._grpid, dim._dimid, namstring)
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -15374,14 +15477,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
*/
}
- /* "netCDF4/_netCDF4.pyx":2027
+ /* "netCDF4/_netCDF4.pyx":2037
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # remove old key from dimensions dict.
* self.dimensions.pop(oldname) # <<<<<<<<<<<<<<
* # add new key.
* self.dimensions[newname] = dim
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dimensions, __pyx_n_s_pop); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dimensions, __pyx_n_s_pop); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2037, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -15394,32 +15497,32 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
}
}
if (!__pyx_t_1) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_oldname); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_oldname); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2037, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2037, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_INCREF(__pyx_v_oldname);
__Pyx_GIVEREF(__pyx_v_oldname);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_oldname);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2037, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":2029
+ /* "netCDF4/_netCDF4.pyx":2039
* self.dimensions.pop(oldname)
* # add new key.
* self.dimensions[newname] = dim # <<<<<<<<<<<<<<
* # Variable.dimensions is determined by a method that
* # looks in the file, so no need to manually update.
*/
- if (unlikely(PyObject_SetItem(__pyx_v_self->dimensions, __pyx_v_newname, __pyx_v_dim) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2029; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_self->dimensions, __pyx_v_newname, __pyx_v_dim) < 0)) __PYX_ERR(0, 2039, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2009
+ /* "netCDF4/_netCDF4.pyx":2019
* return self.dimensions[dimname]
*
* def renameDimension(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -15446,7 +15549,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_32renameDimension(struct _
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2033
+/* "netCDF4/_netCDF4.pyx":2043
* # looks in the file, so no need to manually update.
*
* def createCompoundType(self, datatype, datatype_name): # <<<<<<<<<<<<<<
@@ -15460,9 +15563,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_34createCompoundType[] = "\n**
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_35createCompoundType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_datatype = 0;
PyObject *__pyx_v_datatype_name = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("createCompoundType (wrapper)", 0);
@@ -15486,11 +15586,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_35createCompoundType(PyObj
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_datatype_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("createCompoundType", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2033; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createCompoundType", 1, 2, 2, 1); __PYX_ERR(0, 2043, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createCompoundType") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2033; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createCompoundType") < 0)) __PYX_ERR(0, 2043, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -15503,7 +15603,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_35createCompoundType(PyObj
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("createCompoundType", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2033; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createCompoundType", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2043, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.createCompoundType", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -15521,19 +15621,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_34createCompoundType(struc
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("createCompoundType", 0);
- /* "netCDF4/_netCDF4.pyx":2047
+ /* "netCDF4/_netCDF4.pyx":2057
* The return value is the `netCDF4.CompoundType` class instance describing the new
* datatype."""
* self.cmptypes[datatype_name] = CompoundType(self, datatype,\ # <<<<<<<<<<<<<<
* datatype_name)
* return self.cmptypes[datatype_name]
*/
- __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2057, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
@@ -15544,13 +15641,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_34createCompoundType(struc
__Pyx_INCREF(__pyx_v_datatype_name);
__Pyx_GIVEREF(__pyx_v_datatype_name);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_datatype_name);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_CompoundType), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_CompoundType), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2057, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_self->cmptypes, __pyx_v_datatype_name, __pyx_t_2) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_self->cmptypes, __pyx_v_datatype_name, __pyx_t_2) < 0)) __PYX_ERR(0, 2057, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2049
+ /* "netCDF4/_netCDF4.pyx":2059
* self.cmptypes[datatype_name] = CompoundType(self, datatype,\
* datatype_name)
* return self.cmptypes[datatype_name] # <<<<<<<<<<<<<<
@@ -15558,13 +15655,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_34createCompoundType(struc
* def createVLType(self, datatype, datatype_name):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = PyObject_GetItem(__pyx_v_self->cmptypes, __pyx_v_datatype_name); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2049; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_v_self->cmptypes, __pyx_v_datatype_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2059, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2033
+ /* "netCDF4/_netCDF4.pyx":2043
* # looks in the file, so no need to manually update.
*
* def createCompoundType(self, datatype, datatype_name): # <<<<<<<<<<<<<<
@@ -15584,7 +15681,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_34createCompoundType(struc
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2051
+/* "netCDF4/_netCDF4.pyx":2061
* return self.cmptypes[datatype_name]
*
* def createVLType(self, datatype, datatype_name): # <<<<<<<<<<<<<<
@@ -15598,9 +15695,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_36createVLType[] = "\n**`creat
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_37createVLType(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_datatype = 0;
PyObject *__pyx_v_datatype_name = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("createVLType (wrapper)", 0);
@@ -15624,11 +15718,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_37createVLType(PyObject *_
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_datatype_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("createVLType", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2051; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createVLType", 1, 2, 2, 1); __PYX_ERR(0, 2061, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createVLType") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2051; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createVLType") < 0)) __PYX_ERR(0, 2061, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -15641,7 +15735,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_37createVLType(PyObject *_
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("createVLType", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2051; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createVLType", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2061, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.createVLType", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -15659,19 +15753,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_36createVLType(struct __py
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("createVLType", 0);
- /* "netCDF4/_netCDF4.pyx":2060
+ /* "netCDF4/_netCDF4.pyx":2070
* The return value is the `netCDF4.VLType` class instance describing the new
* datatype."""
* self.vltypes[datatype_name] = VLType(self, datatype, datatype_name) # <<<<<<<<<<<<<<
* return self.vltypes[datatype_name]
*
*/
- __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2070, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
@@ -15682,13 +15773,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_36createVLType(struct __py
__Pyx_INCREF(__pyx_v_datatype_name);
__Pyx_GIVEREF(__pyx_v_datatype_name);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_datatype_name);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_VLType), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_VLType), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2070, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_self->vltypes, __pyx_v_datatype_name, __pyx_t_2) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_self->vltypes, __pyx_v_datatype_name, __pyx_t_2) < 0)) __PYX_ERR(0, 2070, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2061
+ /* "netCDF4/_netCDF4.pyx":2071
* datatype."""
* self.vltypes[datatype_name] = VLType(self, datatype, datatype_name)
* return self.vltypes[datatype_name] # <<<<<<<<<<<<<<
@@ -15696,13 +15787,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_36createVLType(struct __py
* def createEnumType(self, datatype, datatype_name, enum_dict):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = PyObject_GetItem(__pyx_v_self->vltypes, __pyx_v_datatype_name); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2061; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_v_self->vltypes, __pyx_v_datatype_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2071, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2051
+ /* "netCDF4/_netCDF4.pyx":2061
* return self.cmptypes[datatype_name]
*
* def createVLType(self, datatype, datatype_name): # <<<<<<<<<<<<<<
@@ -15722,7 +15813,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_36createVLType(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2063
+/* "netCDF4/_netCDF4.pyx":2073
* return self.vltypes[datatype_name]
*
* def createEnumType(self, datatype, datatype_name, enum_dict): # <<<<<<<<<<<<<<
@@ -15737,9 +15828,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_39createEnumType(PyObject
PyObject *__pyx_v_datatype = 0;
PyObject *__pyx_v_datatype_name = 0;
PyObject *__pyx_v_enum_dict = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("createEnumType (wrapper)", 0);
@@ -15764,16 +15852,16 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_39createEnumType(PyObject
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_datatype_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("createEnumType", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2063; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createEnumType", 1, 3, 3, 1); __PYX_ERR(0, 2073, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_enum_dict)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("createEnumType", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2063; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createEnumType", 1, 3, 3, 2); __PYX_ERR(0, 2073, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createEnumType") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2063; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createEnumType") < 0)) __PYX_ERR(0, 2073, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
@@ -15788,7 +15876,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_39createEnumType(PyObject
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("createEnumType", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2063; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createEnumType", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2073, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.createEnumType", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -15806,19 +15894,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_38createEnumType(struct __
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("createEnumType", 0);
- /* "netCDF4/_netCDF4.pyx":2073
+ /* "netCDF4/_netCDF4.pyx":2083
* The return value is the `netCDF4.EnumType` class instance describing the new
* datatype."""
* self.enumtypes[datatype_name] = EnumType(self, datatype, datatype_name, # <<<<<<<<<<<<<<
* enum_dict)
* return self.enumtypes[datatype_name]
*/
- __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2073; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2083, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
@@ -15832,13 +15917,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_38createEnumType(struct __
__Pyx_INCREF(__pyx_v_enum_dict);
__Pyx_GIVEREF(__pyx_v_enum_dict);
PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_enum_dict);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_EnumType), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2073; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_EnumType), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2083, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_self->enumtypes, __pyx_v_datatype_name, __pyx_t_2) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2073; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_self->enumtypes, __pyx_v_datatype_name, __pyx_t_2) < 0)) __PYX_ERR(0, 2083, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2075
+ /* "netCDF4/_netCDF4.pyx":2085
* self.enumtypes[datatype_name] = EnumType(self, datatype, datatype_name,
* enum_dict)
* return self.enumtypes[datatype_name] # <<<<<<<<<<<<<<
@@ -15846,13 +15931,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_38createEnumType(struct __
* def createVariable(self, varname, datatype, dimensions=(), zlib=False,
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = PyObject_GetItem(__pyx_v_self->enumtypes, __pyx_v_datatype_name); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2075; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_v_self->enumtypes, __pyx_v_datatype_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2085, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2063
+ /* "netCDF4/_netCDF4.pyx":2073
* return self.vltypes[datatype_name]
*
* def createEnumType(self, datatype, datatype_name, enum_dict): # <<<<<<<<<<<<<<
@@ -15872,7 +15957,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_38createEnumType(struct __
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2077
+/* "netCDF4/_netCDF4.pyx":2087
* return self.enumtypes[datatype_name]
*
* def createVariable(self, varname, datatype, dimensions=(), zlib=False, # <<<<<<<<<<<<<<
@@ -15882,7 +15967,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_38createEnumType(struct __
/* Python wrapper */
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
-static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_40createVariable[] = "\n**`createVariable(self, varname, datatype, dimensions=(), zlib=False,\ncomplevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None,\nendian='native', least_significant_digit=None, fill_value=None)`**\n\nCreates a new variable with the given `varname`, `datatype`, and\n`dimensions`. If dimensions are not given, the variable is assumed to be\na scalar.\n\nIf `varname` is specified as a path, using [...]
+static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_40createVariable[] = "\n**`createVariable(self, varname, datatype, dimensions=(), zlib=False,\ncomplevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None,\nendian='native', least_significant_digit=None, fill_value=None)`**\n\nCreates a new variable with the given `varname`, `datatype`, and\n`dimensions`. If dimensions are not given, the variable is assumed to be\na scalar.\n\nIf `varname` is specified as a path, using [...]
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_varname = 0;
PyObject *__pyx_v_datatype = 0;
@@ -15897,9 +15982,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject
PyObject *__pyx_v_least_significant_digit = 0;
PyObject *__pyx_v_fill_value = 0;
PyObject *__pyx_v_chunk_cache = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("createVariable (wrapper)", 0);
@@ -15910,7 +15992,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject
values[3] = ((PyObject *)Py_False);
values[4] = ((PyObject *)__pyx_int_4);
- /* "netCDF4/_netCDF4.pyx":2078
+ /* "netCDF4/_netCDF4.pyx":2088
*
* def createVariable(self, varname, datatype, dimensions=(), zlib=False,
* complevel=4, shuffle=True, fletcher32=False, contiguous=False, # <<<<<<<<<<<<<<
@@ -15921,7 +16003,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject
values[6] = ((PyObject *)Py_False);
values[7] = ((PyObject *)Py_False);
- /* "netCDF4/_netCDF4.pyx":2079
+ /* "netCDF4/_netCDF4.pyx":2089
* def createVariable(self, varname, datatype, dimensions=(), zlib=False,
* complevel=4, shuffle=True, fletcher32=False, contiguous=False,
* chunksizes=None, endian='native', least_significant_digit=None, # <<<<<<<<<<<<<<
@@ -15932,7 +16014,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject
values[9] = ((PyObject *)__pyx_n_s_native);
values[10] = ((PyObject *)Py_None);
- /* "netCDF4/_netCDF4.pyx":2080
+ /* "netCDF4/_netCDF4.pyx":2090
* complevel=4, shuffle=True, fletcher32=False, contiguous=False,
* chunksizes=None, endian='native', least_significant_digit=None,
* fill_value=None, chunk_cache=None): # <<<<<<<<<<<<<<
@@ -15969,7 +16051,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_datatype)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("createVariable", 0, 2, 13, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2077; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createVariable", 0, 2, 13, 1); __PYX_ERR(0, 2087, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
@@ -16028,7 +16110,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createVariable") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2077; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "createVariable") < 0)) __PYX_ERR(0, 2087, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -16065,7 +16147,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("createVariable", 0, 2, 13, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2077; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("createVariable", 0, 2, 13, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2087, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.createVariable", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -16073,7 +16155,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_41createVariable(PyObject
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(((struct __pyx_obj_7netCDF4_8_netCDF4_Dataset *)__pyx_v_self), __pyx_v_varname, __pyx_v_datatype, __pyx_v_dimensions, __pyx_v_zlib, __pyx_v_complevel, __pyx_v_shuffle, __pyx_v_fletcher32, __pyx_v_contiguous, __pyx_v_chunksizes, __pyx_v_endian, __pyx_v_least_significant_digit, __pyx_v_fill_value, __pyx_v_chunk_cache);
- /* "netCDF4/_netCDF4.pyx":2077
+ /* "netCDF4/_netCDF4.pyx":2087
* return self.enumtypes[datatype_name]
*
* def createVariable(self, varname, datatype, dimensions=(), zlib=False, # <<<<<<<<<<<<<<
@@ -16098,22 +16180,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
PyObject *(*__pyx_t_5)(PyObject *);
int __pyx_t_6;
int __pyx_t_7;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("createVariable", 0);
__Pyx_INCREF(__pyx_v_varname);
- /* "netCDF4/_netCDF4.pyx":2204
+ /* "netCDF4/_netCDF4.pyx":2214
* is the number of variable dimensions."""
* # if varname specified as a path, split out group names.
* varname = posixpath.normpath(varname) # <<<<<<<<<<<<<<
* dirname, varname = posixpath.split(varname) # varname is last.
* # create parent groups (like mkdir -p).
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2214, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_normpath); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_normpath); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2214, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -16127,16 +16206,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
}
}
if (!__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_varname); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_varname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2214, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2214, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_varname);
__Pyx_GIVEREF(__pyx_v_varname);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_varname);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2214, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -16144,16 +16223,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
__Pyx_DECREF_SET(__pyx_v_varname, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2205
+ /* "netCDF4/_netCDF4.pyx":2215
* # if varname specified as a path, split out group names.
* varname = posixpath.normpath(varname)
* dirname, varname = posixpath.split(varname) # varname is last. # <<<<<<<<<<<<<<
* # create parent groups (like mkdir -p).
* if not dirname:
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -16167,16 +16246,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_varname); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_varname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_varname);
__Pyx_GIVEREF(__pyx_v_varname);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_varname);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -16191,7 +16270,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2215, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -16204,15 +16283,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_2);
#else
- __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext;
@@ -16220,7 +16299,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
__Pyx_GOTREF(__pyx_t_4);
index = 1; __pyx_t_2 = __pyx_t_5(__pyx_t_3); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
__Pyx_GOTREF(__pyx_t_2);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_3), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_3), 2) < 0) __PYX_ERR(0, 2215, __pyx_L1_error)
__pyx_t_5 = NULL;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L4_unpacking_done;
@@ -16228,7 +16307,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_5 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2215, __pyx_L1_error)
__pyx_L4_unpacking_done:;
}
__pyx_v_dirname = __pyx_t_4;
@@ -16236,18 +16315,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
__Pyx_DECREF_SET(__pyx_v_varname, __pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2207
+ /* "netCDF4/_netCDF4.pyx":2217
* dirname, varname = posixpath.split(varname) # varname is last.
* # create parent groups (like mkdir -p).
* if not dirname: # <<<<<<<<<<<<<<
* group = self
* else:
*/
- __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_dirname); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2207; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_dirname); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 2217, __pyx_L1_error)
__pyx_t_7 = ((!__pyx_t_6) != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":2208
+ /* "netCDF4/_netCDF4.pyx":2218
* # create parent groups (like mkdir -p).
* if not dirname:
* group = self # <<<<<<<<<<<<<<
@@ -16257,7 +16336,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__pyx_v_group = ((PyObject *)__pyx_v_self);
- /* "netCDF4/_netCDF4.pyx":2207
+ /* "netCDF4/_netCDF4.pyx":2217
* dirname, varname = posixpath.split(varname) # varname is last.
* # create parent groups (like mkdir -p).
* if not dirname: # <<<<<<<<<<<<<<
@@ -16267,7 +16346,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
goto __pyx_L5;
}
- /* "netCDF4/_netCDF4.pyx":2210
+ /* "netCDF4/_netCDF4.pyx":2220
* group = self
* else:
* group = self.createGroup(dirname) # <<<<<<<<<<<<<<
@@ -16275,7 +16354,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
* group.variables[varname] = Variable(group, varname, datatype,
*/
/*else*/ {
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createGroup); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_createGroup); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -16288,16 +16367,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
}
}
if (!__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_dirname); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_dirname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_dirname);
__Pyx_GIVEREF(__pyx_v_dirname);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_dirname);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
@@ -16307,14 +16386,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
}
__pyx_L5:;
- /* "netCDF4/_netCDF4.pyx":2212
+ /* "netCDF4/_netCDF4.pyx":2222
* group = self.createGroup(dirname)
* # create variable.
* group.variables[varname] = Variable(group, varname, datatype, # <<<<<<<<<<<<<<
* dimensions=dimensions, zlib=zlib, complevel=complevel, shuffle=shuffle,
* fletcher32=fletcher32, contiguous=contiguous, chunksizes=chunksizes,
*/
- __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2212; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -16326,69 +16405,69 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
__Pyx_GIVEREF(__pyx_v_datatype);
PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_datatype);
- /* "netCDF4/_netCDF4.pyx":2213
+ /* "netCDF4/_netCDF4.pyx":2223
* # create variable.
* group.variables[varname] = Variable(group, varname, datatype,
* dimensions=dimensions, zlib=zlib, complevel=complevel, shuffle=shuffle, # <<<<<<<<<<<<<<
* fletcher32=fletcher32, contiguous=contiguous, chunksizes=chunksizes,
* endian=endian, least_significant_digit=least_significant_digit,
*/
- __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dimensions, __pyx_v_dimensions) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_zlib, __pyx_v_zlib) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_complevel, __pyx_v_complevel) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_shuffle, __pyx_v_shuffle) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dimensions, __pyx_v_dimensions) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_zlib, __pyx_v_zlib) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_complevel, __pyx_v_complevel) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_shuffle, __pyx_v_shuffle) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2214
+ /* "netCDF4/_netCDF4.pyx":2224
* group.variables[varname] = Variable(group, varname, datatype,
* dimensions=dimensions, zlib=zlib, complevel=complevel, shuffle=shuffle,
* fletcher32=fletcher32, contiguous=contiguous, chunksizes=chunksizes, # <<<<<<<<<<<<<<
* endian=endian, least_significant_digit=least_significant_digit,
* fill_value=fill_value, chunk_cache=chunk_cache)
*/
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_fletcher32, __pyx_v_fletcher32) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_contiguous, __pyx_v_contiguous) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_chunksizes, __pyx_v_chunksizes) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_fletcher32, __pyx_v_fletcher32) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_contiguous, __pyx_v_contiguous) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_chunksizes, __pyx_v_chunksizes) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2215
+ /* "netCDF4/_netCDF4.pyx":2225
* dimensions=dimensions, zlib=zlib, complevel=complevel, shuffle=shuffle,
* fletcher32=fletcher32, contiguous=contiguous, chunksizes=chunksizes,
* endian=endian, least_significant_digit=least_significant_digit, # <<<<<<<<<<<<<<
* fill_value=fill_value, chunk_cache=chunk_cache)
* return group.variables[varname]
*/
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_endian, __pyx_v_endian) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_least_significant_digit, __pyx_v_least_significant_digit) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_endian, __pyx_v_endian) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_least_significant_digit, __pyx_v_least_significant_digit) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2216
+ /* "netCDF4/_netCDF4.pyx":2226
* fletcher32=fletcher32, contiguous=contiguous, chunksizes=chunksizes,
* endian=endian, least_significant_digit=least_significant_digit,
* fill_value=fill_value, chunk_cache=chunk_cache) # <<<<<<<<<<<<<<
* return group.variables[varname]
*
*/
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_fill_value, __pyx_v_fill_value) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_chunk_cache, __pyx_v_chunk_cache) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_fill_value, __pyx_v_fill_value) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_chunk_cache, __pyx_v_chunk_cache) < 0) __PYX_ERR(0, 2223, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2212
+ /* "netCDF4/_netCDF4.pyx":2222
* group = self.createGroup(dirname)
* # create variable.
* group.variables[varname] = Variable(group, varname, datatype, # <<<<<<<<<<<<<<
* dimensions=dimensions, zlib=zlib, complevel=complevel, shuffle=shuffle,
* fletcher32=fletcher32, contiguous=contiguous, chunksizes=chunksizes,
*/
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2212; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2212; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_varname, __pyx_t_3) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2212; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_varname, __pyx_t_3) < 0)) __PYX_ERR(0, 2222, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2217
+ /* "netCDF4/_netCDF4.pyx":2227
* endian=endian, least_significant_digit=least_significant_digit,
* fill_value=fill_value, chunk_cache=chunk_cache)
* return group.variables[varname] # <<<<<<<<<<<<<<
@@ -16396,16 +16475,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
* def renameVariable(self, oldname, newname):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_v_varname); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2217; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_v_varname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2077
+ /* "netCDF4/_netCDF4.pyx":2087
* return self.enumtypes[datatype_name]
*
* def createVariable(self, varname, datatype, dimensions=(), zlib=False, # <<<<<<<<<<<<<<
@@ -16430,7 +16509,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_40createVariable(struct __
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2219
+/* "netCDF4/_netCDF4.pyx":2229
* return group.variables[varname]
*
* def renameVariable(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -16444,9 +16523,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_42renameVariable[] = "\n**`ren
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_43renameVariable(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_oldname = 0;
PyObject *__pyx_v_newname = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("renameVariable (wrapper)", 0);
@@ -16470,11 +16546,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_43renameVariable(PyObject
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_newname)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("renameVariable", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2219; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameVariable", 1, 2, 2, 1); __PYX_ERR(0, 2229, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameVariable") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2219; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameVariable") < 0)) __PYX_ERR(0, 2229, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -16487,7 +16563,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_43renameVariable(PyObject
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("renameVariable", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2219; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameVariable", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2229, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.renameVariable", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -16518,12 +16594,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
PyObject *__pyx_t_9 = NULL;
char *__pyx_t_10;
int __pyx_t_11;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("renameVariable", 0);
- /* "netCDF4/_netCDF4.pyx":2225
+ /* "netCDF4/_netCDF4.pyx":2235
* rename a `netCDF4.Variable` named `oldname` to `newname`"""
* cdef char *namstring
* try: # <<<<<<<<<<<<<<
@@ -16531,25 +16604,27 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_1);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":2226
+ /* "netCDF4/_netCDF4.pyx":2236
* cdef char *namstring
* try:
* var = self.variables[oldname] # <<<<<<<<<<<<<<
* except KeyError:
* raise KeyError('%s not a valid variable name' % oldname)
*/
- __pyx_t_4 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_oldname); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2226; __pyx_clineno = __LINE__; goto __pyx_L3_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_oldname); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2236, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_v_var = __pyx_t_4;
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":2225
+ /* "netCDF4/_netCDF4.pyx":2235
* rename a `netCDF4.Variable` named `oldname` to `newname`"""
* cdef char *namstring
* try: # <<<<<<<<<<<<<<
@@ -16562,54 +16637,56 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L10_try_end;
__pyx_L3_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":2227
+ /* "netCDF4/_netCDF4.pyx":2237
* try:
* var = self.variables[oldname]
* except KeyError: # <<<<<<<<<<<<<<
* raise KeyError('%s not a valid variable name' % oldname)
* bytestr = _strencode(newname)
*/
- __pyx_t_5 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_5) {
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.renameVariable", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2227; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;}
+ if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 2237, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_7);
- /* "netCDF4/_netCDF4.pyx":2228
+ /* "netCDF4/_netCDF4.pyx":2238
* var = self.variables[oldname]
* except KeyError:
* raise KeyError('%s not a valid variable name' % oldname) # <<<<<<<<<<<<<<
* bytestr = _strencode(newname)
* namstring = bytestr
*/
- __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_not_a_valid_variable_name, __pyx_v_oldname); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2228; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;}
+ __pyx_t_8 = __Pyx_PyString_Format(__pyx_kp_s_s_not_a_valid_variable_name, __pyx_v_oldname); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2238, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2228; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;}
+ __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2238, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8);
__pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2228; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2238, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2228; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;}
+ __PYX_ERR(0, 2238, __pyx_L5_except_error)
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
- /* "netCDF4/_netCDF4.pyx":2225
+ /* "netCDF4/_netCDF4.pyx":2235
* rename a `netCDF4.Variable` named `oldname` to `newname`"""
* cdef char *namstring
* try: # <<<<<<<<<<<<<<
* var = self.variables[oldname]
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
@@ -16618,38 +16695,38 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
__pyx_L10_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":2229
+ /* "netCDF4/_netCDF4.pyx":2239
* except KeyError:
* raise KeyError('%s not a valid variable name' % oldname)
* bytestr = _strencode(newname) # <<<<<<<<<<<<<<
* namstring = bytestr
* if self.data_model != 'NETCDF4': self._redef()
*/
- __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_newname, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2229; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_newname, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2239, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_v_bytestr = __pyx_t_7;
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2230
+ /* "netCDF4/_netCDF4.pyx":2240
* raise KeyError('%s not a valid variable name' % oldname)
* bytestr = _strencode(newname)
* namstring = bytestr # <<<<<<<<<<<<<<
* if self.data_model != 'NETCDF4': self._redef()
* ierr = nc_rename_var(self._grpid, var._varid, namstring)
*/
- __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2230; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 2240, __pyx_L1_error)
__pyx_v_namstring = __pyx_t_10;
- /* "netCDF4/_netCDF4.pyx":2231
+ /* "netCDF4/_netCDF4.pyx":2241
* bytestr = _strencode(newname)
* namstring = bytestr
* if self.data_model != 'NETCDF4': self._redef() # <<<<<<<<<<<<<<
* ierr = nc_rename_var(self._grpid, var._varid, namstring)
* if self.data_model != 'NETCDF4': self._enddef()
*/
- __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 2241, __pyx_L1_error)
if (__pyx_t_11) {
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2241, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -16662,39 +16739,39 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
}
}
if (__pyx_t_4) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2241, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2241, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2232
+ /* "netCDF4/_netCDF4.pyx":2242
* namstring = bytestr
* if self.data_model != 'NETCDF4': self._redef()
* ierr = nc_rename_var(self._grpid, var._varid, namstring) # <<<<<<<<<<<<<<
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR:
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_varid); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_varid); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2242, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2242, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_v_ierr = nc_rename_var(__pyx_v_self->_grpid, __pyx_t_5, __pyx_v_namstring);
- /* "netCDF4/_netCDF4.pyx":2233
+ /* "netCDF4/_netCDF4.pyx":2243
* if self.data_model != 'NETCDF4': self._redef()
* ierr = nc_rename_var(self._grpid, var._varid, namstring)
* if self.data_model != 'NETCDF4': self._enddef() # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2233; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 2243, __pyx_L1_error)
if (__pyx_t_11) {
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2233; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -16707,17 +16784,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
}
}
if (__pyx_t_4) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2233; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2243, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2233; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2243, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2234
+ /* "netCDF4/_netCDF4.pyx":2244
* ierr = nc_rename_var(self._grpid, var._varid, namstring)
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -16727,7 +16804,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
__pyx_t_11 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_11) {
- /* "netCDF4/_netCDF4.pyx":2235
+ /* "netCDF4/_netCDF4.pyx":2245
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -16735,22 +16812,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
* self.variables.pop(oldname)
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2245, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2245, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2245, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2245, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2234
+ /* "netCDF4/_netCDF4.pyx":2244
* ierr = nc_rename_var(self._grpid, var._varid, namstring)
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -16759,14 +16836,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
*/
}
- /* "netCDF4/_netCDF4.pyx":2237
+ /* "netCDF4/_netCDF4.pyx":2247
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # remove old key from dimensions dict.
* self.variables.pop(oldname) # <<<<<<<<<<<<<<
* # add new key.
* self.variables[newname] = var
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_pop); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2237; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_pop); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2247, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -16779,32 +16856,32 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
}
}
if (!__pyx_t_4) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_oldname); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2237; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_oldname); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2247, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2237; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2247, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_oldname);
__Pyx_GIVEREF(__pyx_v_oldname);
PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_oldname);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2237; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2247, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2239
+ /* "netCDF4/_netCDF4.pyx":2249
* self.variables.pop(oldname)
* # add new key.
* self.variables[newname] = var # <<<<<<<<<<<<<<
*
* def createGroup(self, groupname):
*/
- if (unlikely(PyObject_SetItem(__pyx_v_self->variables, __pyx_v_newname, __pyx_v_var) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2239; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_self->variables, __pyx_v_newname, __pyx_v_var) < 0)) __PYX_ERR(0, 2249, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2219
+ /* "netCDF4/_netCDF4.pyx":2229
* return group.variables[varname]
*
* def renameVariable(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -16831,7 +16908,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_42renameVariable(struct __
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2241
+/* "netCDF4/_netCDF4.pyx":2251
* self.variables[newname] = var
*
* def createGroup(self, groupname): # <<<<<<<<<<<<<<
@@ -16867,22 +16944,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
PyObject *(*__pyx_t_6)(PyObject *);
int __pyx_t_7;
int __pyx_t_8;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("createGroup", 0);
__Pyx_INCREF(__pyx_v_groupname);
- /* "netCDF4/_netCDF4.pyx":2257
+ /* "netCDF4/_netCDF4.pyx":2267
* The return value is a `netCDF4.Group` class instance."""
* # if group specified as a path, split out group names
* groupname = posixpath.normpath(groupname) # <<<<<<<<<<<<<<
* nestedgroups = groupname.split('/')
* group = self
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_normpath); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_normpath); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -16896,16 +16970,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
}
}
if (!__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_groupname); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_groupname); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_groupname);
__Pyx_GIVEREF(__pyx_v_groupname);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_groupname);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -16913,22 +16987,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
__Pyx_DECREF_SET(__pyx_v_groupname, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2258
+ /* "netCDF4/_netCDF4.pyx":2268
* # if group specified as a path, split out group names
* groupname = posixpath.normpath(groupname)
* nestedgroups = groupname.split('/') # <<<<<<<<<<<<<<
* group = self
* # loop over group names, create parent groups if they do not already
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_groupname, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2258; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_groupname, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2268, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2258; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2268, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_nestedgroups = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2259
+ /* "netCDF4/_netCDF4.pyx":2269
* groupname = posixpath.normpath(groupname)
* nestedgroups = groupname.split('/')
* group = self # <<<<<<<<<<<<<<
@@ -16938,7 +17012,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__pyx_v_group = ((PyObject *)__pyx_v_self);
- /* "netCDF4/_netCDF4.pyx":2262
+ /* "netCDF4/_netCDF4.pyx":2272
* # loop over group names, create parent groups if they do not already
* # exist.
* for g in nestedgroups: # <<<<<<<<<<<<<<
@@ -16949,26 +17023,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
__pyx_t_3 = __pyx_v_nestedgroups; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_nestedgroups); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_nestedgroups); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2272, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_6)) {
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 2272, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 2272, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -16978,7 +17052,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2272, __pyx_L1_error)
}
break;
}
@@ -16987,41 +17061,41 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
__Pyx_XDECREF_SET(__pyx_v_g, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2263
+ /* "netCDF4/_netCDF4.pyx":2273
* # exist.
* for g in nestedgroups:
* if not g: continue # <<<<<<<<<<<<<<
* if g not in group.groups:
* group.groups[g] = Group(group, g)
*/
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_g); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_g); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 2273, __pyx_L1_error)
__pyx_t_8 = ((!__pyx_t_7) != 0);
if (__pyx_t_8) {
goto __pyx_L3_continue;
}
- /* "netCDF4/_netCDF4.pyx":2264
+ /* "netCDF4/_netCDF4.pyx":2274
* for g in nestedgroups:
* if not g: continue
* if g not in group.groups: # <<<<<<<<<<<<<<
* group.groups[g] = Group(group, g)
* group = group.groups[g]
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2264; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_g, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2264; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_v_g, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 2274, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_7 = (__pyx_t_8 != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":2265
+ /* "netCDF4/_netCDF4.pyx":2275
* if not g: continue
* if g not in group.groups:
* group.groups[g] = Group(group, g) # <<<<<<<<<<<<<<
* group = group.groups[g]
* # if group already exists, just return the group
*/
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2265; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2275, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -17029,16 +17103,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
__Pyx_INCREF(__pyx_v_g);
__Pyx_GIVEREF(__pyx_v_g);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_g);
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Group), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2265; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Group), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2275, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2265; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2275, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_g, __pyx_t_4) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2265; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_g, __pyx_t_4) < 0)) __PYX_ERR(0, 2275, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":2264
+ /* "netCDF4/_netCDF4.pyx":2274
* for g in nestedgroups:
* if not g: continue
* if g not in group.groups: # <<<<<<<<<<<<<<
@@ -17047,22 +17121,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":2266
+ /* "netCDF4/_netCDF4.pyx":2276
* if g not in group.groups:
* group.groups[g] = Group(group, g)
* group = group.groups[g] # <<<<<<<<<<<<<<
* # if group already exists, just return the group
* # (prior to 1.1.8, this would have raised an error)
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2266; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_groups); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyObject_GetItem(__pyx_t_4, __pyx_v_g); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2266; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_t_4, __pyx_v_g); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF_SET(__pyx_v_group, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2262
+ /* "netCDF4/_netCDF4.pyx":2272
* # loop over group names, create parent groups if they do not already
* # exist.
* for g in nestedgroups: # <<<<<<<<<<<<<<
@@ -17073,7 +17147,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2269
+ /* "netCDF4/_netCDF4.pyx":2279
* # if group already exists, just return the group
* # (prior to 1.1.8, this would have raised an error)
* return group # <<<<<<<<<<<<<<
@@ -17085,7 +17159,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
__pyx_r = __pyx_v_group;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2241
+ /* "netCDF4/_netCDF4.pyx":2251
* self.variables[newname] = var
*
* def createGroup(self, groupname): # <<<<<<<<<<<<<<
@@ -17111,7 +17185,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_44createGroup(struct __pyx
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2271
+/* "netCDF4/_netCDF4.pyx":2281
* return group
*
* def ncattrs(self): # <<<<<<<<<<<<<<
@@ -17137,12 +17211,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_46ncattrs(struct __pyx_obj
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("ncattrs", 0);
- /* "netCDF4/_netCDF4.pyx":2276
+ /* "netCDF4/_netCDF4.pyx":2286
*
* return netCDF global attribute names for this `netCDF4.Dataset` or `netCDF4.Group` in a list."""
* return _get_att_names(self._grpid, NC_GLOBAL) # <<<<<<<<<<<<<<
@@ -17150,13 +17221,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_46ncattrs(struct __pyx_obj
* def setncattr(self,name,value):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_att_names(__pyx_v_self->_grpid, NC_GLOBAL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2276; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_att_names(__pyx_v_self->_grpid, NC_GLOBAL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2286, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2271
+ /* "netCDF4/_netCDF4.pyx":2281
* return group
*
* def ncattrs(self): # <<<<<<<<<<<<<<
@@ -17175,7 +17246,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_46ncattrs(struct __pyx_obj
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2278
+/* "netCDF4/_netCDF4.pyx":2288
* return _get_att_names(self._grpid, NC_GLOBAL)
*
* def setncattr(self,name,value): # <<<<<<<<<<<<<<
@@ -17189,9 +17260,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_48setncattr[] = "\n**`setncatt
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_49setncattr(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_name = 0;
PyObject *__pyx_v_value = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("setncattr (wrapper)", 0);
@@ -17215,11 +17283,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_49setncattr(PyObject *__py
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("setncattr", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2278; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("setncattr", 1, 2, 2, 1); __PYX_ERR(0, 2288, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setncattr") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2278; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setncattr") < 0)) __PYX_ERR(0, 2288, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -17232,7 +17300,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_49setncattr(PyObject *__py
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("setncattr", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2278; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("setncattr", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2288, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.setncattr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -17252,21 +17320,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_48setncattr(struct __pyx_o
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setncattr", 0);
- /* "netCDF4/_netCDF4.pyx":2285
+ /* "netCDF4/_netCDF4.pyx":2295
* Use if you need to set a netCDF attribute with the
* with the same name as one of the reserved python attributes."""
* if self.data_model != 'NETCDF4': self._redef() # <<<<<<<<<<<<<<
* _set_att(self, NC_GLOBAL, name, value)
* if self.data_model != 'NETCDF4': self._enddef()
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2285; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2295, __pyx_L1_error)
if (__pyx_t_1) {
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2285; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2295, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -17279,37 +17344,37 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_48setncattr(struct __pyx_o
}
}
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2285; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2295, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2285; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2295, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2286
+ /* "netCDF4/_netCDF4.pyx":2296
* with the same name as one of the reserved python attributes."""
* if self.data_model != 'NETCDF4': self._redef()
* _set_att(self, NC_GLOBAL, name, value) # <<<<<<<<<<<<<<
* if self.data_model != 'NETCDF4': self._enddef()
*
*/
- __pyx_t_2 = __pyx_f_7netCDF4_8_netCDF4__set_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name, __pyx_v_value, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2286; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __pyx_f_7netCDF4_8_netCDF4__set_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name, __pyx_v_value, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2296, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2287
+ /* "netCDF4/_netCDF4.pyx":2297
* if self.data_model != 'NETCDF4': self._redef()
* _set_att(self, NC_GLOBAL, name, value)
* if self.data_model != 'NETCDF4': self._enddef() # <<<<<<<<<<<<<<
*
* def setncattr_string(self,name,value):
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2287; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2297, __pyx_L1_error)
if (__pyx_t_1) {
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2287; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2297, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -17322,17 +17387,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_48setncattr(struct __pyx_o
}
}
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2287; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2297, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2287; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2297, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2278
+ /* "netCDF4/_netCDF4.pyx":2288
* return _get_att_names(self._grpid, NC_GLOBAL)
*
* def setncattr(self,name,value): # <<<<<<<<<<<<<<
@@ -17355,7 +17420,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_48setncattr(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2289
+/* "netCDF4/_netCDF4.pyx":2299
* if self.data_model != 'NETCDF4': self._enddef()
*
* def setncattr_string(self,name,value): # <<<<<<<<<<<<<<
@@ -17369,9 +17434,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_50setncattr_string[] = "\n**`s
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_51setncattr_string(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_name = 0;
PyObject *__pyx_v_value = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("setncattr_string (wrapper)", 0);
@@ -17395,11 +17457,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_51setncattr_string(PyObjec
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("setncattr_string", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2289; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("setncattr_string", 1, 2, 2, 1); __PYX_ERR(0, 2299, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setncattr_string") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2289; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setncattr_string") < 0)) __PYX_ERR(0, 2299, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -17412,7 +17474,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_51setncattr_string(PyObjec
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("setncattr_string", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2289; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("setncattr_string", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2299, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.setncattr_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -17434,12 +17496,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_50setncattr_string(struct
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
struct __pyx_opt_args_7netCDF4_8_netCDF4__set_att __pyx_t_4;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setncattr_string", 0);
- /* "netCDF4/_netCDF4.pyx":2297
+ /* "netCDF4/_netCDF4.pyx":2307
* `NC_STRING` if the file format is `NETCDF4`."""
* cdef nc_type xtype
* xtype=-99 # <<<<<<<<<<<<<<
@@ -17448,17 +17507,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_50setncattr_string(struct
*/
__pyx_v_xtype = -99;
- /* "netCDF4/_netCDF4.pyx":2298
+ /* "netCDF4/_netCDF4.pyx":2308
* cdef nc_type xtype
* xtype=-99
* if self.data_model != 'NETCDF4': # <<<<<<<<<<<<<<
* msg='file format does not support NC_STRING attributes'
* raise IOError(msg)
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2298; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2308, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2299
+ /* "netCDF4/_netCDF4.pyx":2309
* xtype=-99
* if self.data_model != 'NETCDF4':
* msg='file format does not support NC_STRING attributes' # <<<<<<<<<<<<<<
@@ -17468,26 +17527,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_50setncattr_string(struct
__Pyx_INCREF(__pyx_kp_s_file_format_does_not_support_NC);
__pyx_v_msg = __pyx_kp_s_file_format_does_not_support_NC;
- /* "netCDF4/_netCDF4.pyx":2300
+ /* "netCDF4/_netCDF4.pyx":2310
* if self.data_model != 'NETCDF4':
* msg='file format does not support NC_STRING attributes'
* raise IOError(msg) # <<<<<<<<<<<<<<
* _set_att(self, NC_GLOBAL, name, str(value), xtype=xtype, force_ncstring=True)
*
*/
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2310, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2310, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2310, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2298
+ /* "netCDF4/_netCDF4.pyx":2308
* cdef nc_type xtype
* xtype=-99
* if self.data_model != 'NETCDF4': # <<<<<<<<<<<<<<
@@ -17496,30 +17555,30 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_50setncattr_string(struct
*/
}
- /* "netCDF4/_netCDF4.pyx":2301
+ /* "netCDF4/_netCDF4.pyx":2311
* msg='file format does not support NC_STRING attributes'
* raise IOError(msg)
* _set_att(self, NC_GLOBAL, name, str(value), xtype=xtype, force_ncstring=True) # <<<<<<<<<<<<<<
*
* def setncatts(self,attdict):
*/
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2301; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2311, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_value);
- __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2301; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2311, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_4.__pyx_n = 2;
__pyx_t_4.xtype = __pyx_v_xtype;
__pyx_t_4.force_ncstring = Py_True;
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__set_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name, __pyx_t_2, &__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2301; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__set_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name, __pyx_t_2, &__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2311, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2289
+ /* "netCDF4/_netCDF4.pyx":2299
* if self.data_model != 'NETCDF4': self._enddef()
*
* def setncattr_string(self,name,value): # <<<<<<<<<<<<<<
@@ -17542,7 +17601,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_50setncattr_string(struct
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2303
+/* "netCDF4/_netCDF4.pyx":2313
* _set_att(self, NC_GLOBAL, name, str(value), xtype=xtype, force_ncstring=True)
*
* def setncatts(self,attdict): # <<<<<<<<<<<<<<
@@ -17578,21 +17637,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *(*__pyx_t_9)(PyObject *);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setncatts", 0);
- /* "netCDF4/_netCDF4.pyx":2311
+ /* "netCDF4/_netCDF4.pyx":2321
* formatted file, since nc_redef/nc_enddef is not called in between setting
* each attribute"""
* if self.data_model != 'NETCDF4': self._redef() # <<<<<<<<<<<<<<
* for name, value in attdict.items():
* _set_att(self, NC_GLOBAL, name, value)
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2311; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2321, __pyx_L1_error)
if (__pyx_t_1) {
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2311; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2321, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -17605,24 +17661,24 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
}
}
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2311; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2321, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2311; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2321, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2312
+ /* "netCDF4/_netCDF4.pyx":2322
* each attribute"""
* if self.data_model != 'NETCDF4': self._redef()
* for name, value in attdict.items(): # <<<<<<<<<<<<<<
* _set_att(self, NC_GLOBAL, name, value)
* if self.data_model != 'NETCDF4': self._enddef()
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_attdict, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_attdict, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2322, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -17635,10 +17691,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
}
}
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2322, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2322, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -17646,9 +17702,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
__pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2322, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2322, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -17656,17 +17712,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 2322, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2322, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 2322, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2322, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -17676,7 +17732,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2322, __pyx_L1_error)
}
break;
}
@@ -17692,7 +17748,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2322, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -17705,15 +17761,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_7);
#else
- __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2322, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2322, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_8 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2322, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext;
@@ -17721,7 +17777,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
__Pyx_GOTREF(__pyx_t_4);
index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed;
__Pyx_GOTREF(__pyx_t_7);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(0, 2322, __pyx_L1_error)
__pyx_t_9 = NULL;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L7_unpacking_done;
@@ -17729,7 +17785,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2322, __pyx_L1_error)
__pyx_L7_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_4);
@@ -17737,18 +17793,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
__Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2313
+ /* "netCDF4/_netCDF4.pyx":2323
* if self.data_model != 'NETCDF4': self._redef()
* for name, value in attdict.items():
* _set_att(self, NC_GLOBAL, name, value) # <<<<<<<<<<<<<<
* if self.data_model != 'NETCDF4': self._enddef()
*
*/
- __pyx_t_2 = __pyx_f_7netCDF4_8_netCDF4__set_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name, __pyx_v_value, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __pyx_f_7netCDF4_8_netCDF4__set_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name, __pyx_v_value, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2323, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2312
+ /* "netCDF4/_netCDF4.pyx":2322
* each attribute"""
* if self.data_model != 'NETCDF4': self._redef()
* for name, value in attdict.items(): # <<<<<<<<<<<<<<
@@ -17758,16 +17814,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2314
+ /* "netCDF4/_netCDF4.pyx":2324
* for name, value in attdict.items():
* _set_att(self, NC_GLOBAL, name, value)
* if self.data_model != 'NETCDF4': self._enddef() # <<<<<<<<<<<<<<
*
* def getncattr(self,name):
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2314; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2324, __pyx_L1_error)
if (__pyx_t_1) {
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2314; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2324, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -17780,17 +17836,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
}
}
if (__pyx_t_7) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2314; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2324, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2314; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2324, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2303
+ /* "netCDF4/_netCDF4.pyx":2313
* _set_att(self, NC_GLOBAL, name, str(value), xtype=xtype, force_ncstring=True)
*
* def setncatts(self,attdict): # <<<<<<<<<<<<<<
@@ -17817,7 +17873,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_52setncatts(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2316
+/* "netCDF4/_netCDF4.pyx":2326
* if self.data_model != 'NETCDF4': self._enddef()
*
* def getncattr(self,name): # <<<<<<<<<<<<<<
@@ -17843,12 +17899,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_54getncattr(struct __pyx_o
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("getncattr", 0);
- /* "netCDF4/_netCDF4.pyx":2323
+ /* "netCDF4/_netCDF4.pyx":2333
* Use if you need to get a netCDF attribute with the same
* name as one of the reserved python attributes."""
* return _get_att(self, NC_GLOBAL, name) # <<<<<<<<<<<<<<
@@ -17856,13 +17909,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_54getncattr(struct __pyx_o
* def __delattr__(self,name):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2323; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2333, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2316
+ /* "netCDF4/_netCDF4.pyx":2326
* if self.data_model != 'NETCDF4': self._enddef()
*
* def getncattr(self,name): # <<<<<<<<<<<<<<
@@ -17881,7 +17934,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_54getncattr(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2325
+/* "netCDF4/_netCDF4.pyx":2335
* return _get_att(self, NC_GLOBAL, name)
*
* def __delattr__(self,name): # <<<<<<<<<<<<<<
@@ -17911,33 +17964,30 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_56__delattr__(struct __pyx_obj_7
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__delattr__", 0);
- /* "netCDF4/_netCDF4.pyx":2327
+ /* "netCDF4/_netCDF4.pyx":2337
* def __delattr__(self,name):
* # if it's a netCDF attribute, remove it
* if name not in _private_atts: # <<<<<<<<<<<<<<
* self.delncattr(name)
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2327; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2327; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2337, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2328
+ /* "netCDF4/_netCDF4.pyx":2338
* # if it's a netCDF attribute, remove it
* if name not in _private_atts:
* self.delncattr(name) # <<<<<<<<<<<<<<
* else:
* raise AttributeError(
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_delncattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2328; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_delncattr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2338, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -17950,23 +18000,23 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_56__delattr__(struct __pyx_obj_7
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2328; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2338, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2328; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2338, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_name);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2328; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2338, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2327
+ /* "netCDF4/_netCDF4.pyx":2337
* def __delattr__(self,name):
* # if it's a netCDF attribute, remove it
* if name not in _private_atts: # <<<<<<<<<<<<<<
@@ -17976,7 +18026,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_56__delattr__(struct __pyx_obj_7
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":2330
+ /* "netCDF4/_netCDF4.pyx":2340
* self.delncattr(name)
* else:
* raise AttributeError( # <<<<<<<<<<<<<<
@@ -17985,19 +18035,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_56__delattr__(struct __pyx_obj_7
*/
/*else*/ {
- /* "netCDF4/_netCDF4.pyx":2331
+ /* "netCDF4/_netCDF4.pyx":2341
* else:
* raise AttributeError(
* "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead." % (name, tuple(_private_atts))) # <<<<<<<<<<<<<<
*
* def delncattr(self, name):
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2331; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2331; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2331; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
@@ -18005,32 +18055,32 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_56__delattr__(struct __pyx_obj_7
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_is_one_of_the_reserved_attrib, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2331; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_is_one_of_the_reserved_attrib, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2330
+ /* "netCDF4/_netCDF4.pyx":2340
* self.delncattr(name)
* else:
* raise AttributeError( # <<<<<<<<<<<<<<
* "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead." % (name, tuple(_private_atts)))
*
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2330; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2340, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2330; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2340, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2330; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2340, __pyx_L1_error)
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":2325
+ /* "netCDF4/_netCDF4.pyx":2335
* return _get_att(self, NC_GLOBAL, name)
*
* def __delattr__(self,name): # <<<<<<<<<<<<<<
@@ -18053,7 +18103,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_56__delattr__(struct __pyx_obj_7
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2333
+/* "netCDF4/_netCDF4.pyx":2343
* "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead." % (name, tuple(_private_atts)))
*
* def delncattr(self, name): # <<<<<<<<<<<<<<
@@ -18086,43 +18136,40 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_58delncattr(struct __pyx_o
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("delncattr", 0);
- /* "netCDF4/_netCDF4.pyx":2342
+ /* "netCDF4/_netCDF4.pyx":2352
* cdef char *attname
* cdef int ierr
* bytestr = _strencode(name) # <<<<<<<<<<<<<<
* attname = bytestr
* if self.data_model != 'NETCDF4': self._redef()
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2343
+ /* "netCDF4/_netCDF4.pyx":2353
* cdef int ierr
* bytestr = _strencode(name)
* attname = bytestr # <<<<<<<<<<<<<<
* if self.data_model != 'NETCDF4': self._redef()
* ierr = nc_del_att(self._grpid, NC_GLOBAL, attname)
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2343; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 2353, __pyx_L1_error)
__pyx_v_attname = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":2344
+ /* "netCDF4/_netCDF4.pyx":2354
* bytestr = _strencode(name)
* attname = bytestr
* if self.data_model != 'NETCDF4': self._redef() # <<<<<<<<<<<<<<
* ierr = nc_del_att(self._grpid, NC_GLOBAL, attname)
* if self.data_model != 'NETCDF4': self._enddef()
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2354, __pyx_L1_error)
if (__pyx_t_3) {
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_redef); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2354, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -18135,17 +18182,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_58delncattr(struct __pyx_o
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2354, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2354, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2345
+ /* "netCDF4/_netCDF4.pyx":2355
* attname = bytestr
* if self.data_model != 'NETCDF4': self._redef()
* ierr = nc_del_att(self._grpid, NC_GLOBAL, attname) # <<<<<<<<<<<<<<
@@ -18154,16 +18201,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_58delncattr(struct __pyx_o
*/
__pyx_v_ierr = nc_del_att(__pyx_v_self->_grpid, NC_GLOBAL, __pyx_v_attname);
- /* "netCDF4/_netCDF4.pyx":2346
+ /* "netCDF4/_netCDF4.pyx":2356
* if self.data_model != 'NETCDF4': self._redef()
* ierr = nc_del_att(self._grpid, NC_GLOBAL, attname)
* if self.data_model != 'NETCDF4': self._enddef() # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2346; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_self->data_model, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2356, __pyx_L1_error)
if (__pyx_t_3) {
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2346; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_enddef); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2356, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -18176,59 +18223,59 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_58delncattr(struct __pyx_o
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2346; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2356, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2346; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2356, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2347
+ /* "netCDF4/_netCDF4.pyx":2357
* ierr = nc_del_att(self._grpid, NC_GLOBAL, attname)
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
*/
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2348
+ /* "netCDF4/_netCDF4.pyx":2358
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
*
* def __setattr__(self,name,value):
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2358, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2358, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2358, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2358, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2347
+ /* "netCDF4/_netCDF4.pyx":2357
* ierr = nc_del_att(self._grpid, NC_GLOBAL, attname)
* if self.data_model != 'NETCDF4': self._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
*/
}
- /* "netCDF4/_netCDF4.pyx":2333
+ /* "netCDF4/_netCDF4.pyx":2343
* "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead." % (name, tuple(_private_atts)))
*
* def delncattr(self, name): # <<<<<<<<<<<<<<
@@ -18252,8 +18299,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_58delncattr(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2350
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+/* "netCDF4/_netCDF4.pyx":2360
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def __setattr__(self,name,value): # <<<<<<<<<<<<<<
* # if name in _private_atts, it is stored at the python
@@ -18283,33 +18330,30 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
PyObject *__pyx_t_5 = NULL;
Py_ssize_t __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setattr__", 0);
- /* "netCDF4/_netCDF4.pyx":2353
+ /* "netCDF4/_netCDF4.pyx":2363
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name not in _private_atts: # <<<<<<<<<<<<<<
* self.setncattr(name, value)
* elif not name.endswith('__'):
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2353; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2353; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2363, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2354
+ /* "netCDF4/_netCDF4.pyx":2364
* # level and not in the netCDF file.
* if name not in _private_atts:
* self.setncattr(name, value) # <<<<<<<<<<<<<<
* elif not name.endswith('__'):
* if hasattr(self,name):
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setncattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2354; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setncattr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2364, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
__pyx_t_6 = 0;
@@ -18323,7 +18367,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
__pyx_t_6 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2354; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2364, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
@@ -18334,13 +18378,13 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_value);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2354; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2364, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2353
+ /* "netCDF4/_netCDF4.pyx":2363
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name not in _private_atts: # <<<<<<<<<<<<<<
@@ -18350,47 +18394,47 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":2355
+ /* "netCDF4/_netCDF4.pyx":2365
* if name not in _private_atts:
* self.setncattr(name, value)
* elif not name.endswith('__'): # <<<<<<<<<<<<<<
* if hasattr(self,name):
* raise AttributeError(
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2355; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2355; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2355; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2365, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_2 = ((!__pyx_t_3) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":2356
+ /* "netCDF4/_netCDF4.pyx":2366
* self.setncattr(name, value)
* elif not name.endswith('__'):
* if hasattr(self,name): # <<<<<<<<<<<<<<
* raise AttributeError(
* "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead." % (name, tuple(_private_atts)))
*/
- __pyx_t_2 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_v_name); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2356; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_v_name); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 2366, __pyx_L1_error)
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2358
+ /* "netCDF4/_netCDF4.pyx":2368
* if hasattr(self,name):
* raise AttributeError(
* "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead." % (name, tuple(_private_atts))) # <<<<<<<<<<<<<<
* else:
* self.__dict__[name]=value
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2358; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2368, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2358; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2368, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2358; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2368, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
@@ -18398,30 +18442,30 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_is_one_of_the_reserved_attrib_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2358; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_is_one_of_the_reserved_attrib_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2368, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":2357
+ /* "netCDF4/_netCDF4.pyx":2367
* elif not name.endswith('__'):
* if hasattr(self,name):
* raise AttributeError( # <<<<<<<<<<<<<<
* "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead." % (name, tuple(_private_atts)))
* else:
*/
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2367, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2367, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2367, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2356
+ /* "netCDF4/_netCDF4.pyx":2366
* self.setncattr(name, value)
* elif not name.endswith('__'):
* if hasattr(self,name): # <<<<<<<<<<<<<<
@@ -18430,7 +18474,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":2360
+ /* "netCDF4/_netCDF4.pyx":2370
* "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead." % (name, tuple(_private_atts)))
* else:
* self.__dict__[name]=value # <<<<<<<<<<<<<<
@@ -18438,13 +18482,13 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
* def __getattr__(self,name):
*/
/*else*/ {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dict); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2360; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_name, __pyx_v_value) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2360; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_name, __pyx_v_value) < 0)) __PYX_ERR(0, 2370, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2355
+ /* "netCDF4/_netCDF4.pyx":2365
* if name not in _private_atts:
* self.setncattr(name, value)
* elif not name.endswith('__'): # <<<<<<<<<<<<<<
@@ -18454,8 +18498,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":2350
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ /* "netCDF4/_netCDF4.pyx":2360
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def __setattr__(self,name,value): # <<<<<<<<<<<<<<
* # if name in _private_atts, it is stored at the python
@@ -18477,7 +18521,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_60__setattr__(struct __pyx_obj_7
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2362
+/* "netCDF4/_netCDF4.pyx":2372
* self.__dict__[name]=value
*
* def __getattr__(self,name): # <<<<<<<<<<<<<<
@@ -18514,60 +18558,57 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getattr__", 0);
__Pyx_INCREF(__pyx_v_name);
- /* "netCDF4/_netCDF4.pyx":2365
+ /* "netCDF4/_netCDF4.pyx":2375
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<<
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__':
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__30, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 2375, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_4) {
} else {
__pyx_t_1 = __pyx_t_4;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 2375, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_1 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2367
+ /* "netCDF4/_netCDF4.pyx":2377
* if name.startswith('__') and name.endswith('__'):
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__': # <<<<<<<<<<<<<<
* names = self.ncattrs()
* values = []
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_dict, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2367; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_dict, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2377, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2368
+ /* "netCDF4/_netCDF4.pyx":2378
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__':
* names = self.ncattrs() # <<<<<<<<<<<<<<
* values = []
* for name in names:
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -18580,29 +18621,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
}
}
if (__pyx_t_5) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2378, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2378, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_names = __pyx_t_2;
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2369
+ /* "netCDF4/_netCDF4.pyx":2379
* if name == '__dict__':
* names = self.ncattrs()
* values = [] # <<<<<<<<<<<<<<
* for name in names:
* values.append(_get_att(self, NC_GLOBAL, name))
*/
- __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2369; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_v_values = ((PyObject*)__pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2370
+ /* "netCDF4/_netCDF4.pyx":2380
* names = self.ncattrs()
* values = []
* for name in names: # <<<<<<<<<<<<<<
@@ -18613,26 +18654,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
__pyx_t_2 = __pyx_v_names; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_names); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2380, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_7)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 2380, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 2380, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
}
@@ -18642,7 +18683,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2380, __pyx_L1_error)
}
break;
}
@@ -18651,19 +18692,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
__Pyx_DECREF_SET(__pyx_v_name, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2371
+ /* "netCDF4/_netCDF4.pyx":2381
* values = []
* for name in names:
* values.append(_get_att(self, NC_GLOBAL, name)) # <<<<<<<<<<<<<<
* return OrderedDict(zip(names,values))
* else:
*/
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__get_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__get_att(((PyObject *)__pyx_v_self), NC_GLOBAL, __pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_values, __pyx_t_3); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_values, __pyx_t_3); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 2381, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2370
+ /* "netCDF4/_netCDF4.pyx":2380
* names = self.ncattrs()
* values = []
* for name in names: # <<<<<<<<<<<<<<
@@ -18673,7 +18714,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2372
+ /* "netCDF4/_netCDF4.pyx":2382
* for name in names:
* values.append(_get_att(self, NC_GLOBAL, name))
* return OrderedDict(zip(names,values)) # <<<<<<<<<<<<<<
@@ -18681,9 +18722,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
* raise AttributeError
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_10 = NULL;
__pyx_t_6 = 0;
@@ -18697,7 +18738,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
__pyx_t_6 = 1;
}
}
- __pyx_t_11 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
if (__pyx_t_10) {
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL;
@@ -18708,7 +18749,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
__Pyx_INCREF(__pyx_v_values);
__Pyx_GIVEREF(__pyx_v_values);
PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_6, __pyx_v_values);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -18723,17 +18764,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
}
}
if (!__pyx_t_9) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2382, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL;
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_5);
__pyx_t_5 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2372; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
}
@@ -18742,7 +18783,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2367
+ /* "netCDF4/_netCDF4.pyx":2377
* if name.startswith('__') and name.endswith('__'):
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__': # <<<<<<<<<<<<<<
@@ -18751,7 +18792,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":2374
+ /* "netCDF4/_netCDF4.pyx":2384
* return OrderedDict(zip(names,values))
* else:
* raise AttributeError # <<<<<<<<<<<<<<
@@ -18760,10 +18801,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
*/
/*else*/ {
__Pyx_Raise(__pyx_builtin_AttributeError, 0, 0, 0);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2374; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2384, __pyx_L1_error)
}
- /* "netCDF4/_netCDF4.pyx":2365
+ /* "netCDF4/_netCDF4.pyx":2375
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<<
@@ -18772,21 +18813,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":2375
+ /* "netCDF4/_netCDF4.pyx":2385
* else:
* raise AttributeError
* elif name in _private_atts: # <<<<<<<<<<<<<<
* return self.__dict__[name]
* else:
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2375; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2385, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2375; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2385, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = (__pyx_t_1 != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":2376
+ /* "netCDF4/_netCDF4.pyx":2386
* raise AttributeError
* elif name in _private_atts:
* return self.__dict__[name] # <<<<<<<<<<<<<<
@@ -18794,16 +18835,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
* return self.getncattr(name)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2376; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_v_name); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2376; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2375
+ /* "netCDF4/_netCDF4.pyx":2385
* else:
* raise AttributeError
* elif name in _private_atts: # <<<<<<<<<<<<<<
@@ -18812,7 +18853,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":2378
+ /* "netCDF4/_netCDF4.pyx":2388
* return self.__dict__[name]
* else:
* return self.getncattr(name) # <<<<<<<<<<<<<<
@@ -18821,7 +18862,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getncattr); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getncattr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_11 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -18834,16 +18875,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
}
}
if (!__pyx_t_11) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_name); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_11); __pyx_t_11 = NULL;
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_name);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
@@ -18853,7 +18894,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":2362
+ /* "netCDF4/_netCDF4.pyx":2372
* self.__dict__[name]=value
*
* def __getattr__(self,name): # <<<<<<<<<<<<<<
@@ -18880,7 +18921,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_62__getattr__(struct __pyx
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2380
+/* "netCDF4/_netCDF4.pyx":2390
* return self.getncattr(name)
*
* def renameAttribute(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -18894,9 +18935,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_64renameAttribute[] = "\n**`re
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_65renameAttribute(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_oldname = 0;
PyObject *__pyx_v_newname = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("renameAttribute (wrapper)", 0);
@@ -18920,11 +18958,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_65renameAttribute(PyObject
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_newname)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("renameAttribute", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2380; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameAttribute", 1, 2, 2, 1); __PYX_ERR(0, 2390, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameAttribute") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2380; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameAttribute") < 0)) __PYX_ERR(0, 2390, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -18937,7 +18975,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_65renameAttribute(PyObject
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("renameAttribute", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2380; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameAttribute", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2390, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.renameAttribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -18961,56 +18999,53 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_64renameAttribute(struct _
char *__pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("renameAttribute", 0);
- /* "netCDF4/_netCDF4.pyx":2388
+ /* "netCDF4/_netCDF4.pyx":2398
* cdef char *oldnamec
* cdef char *newnamec
* bytestr = _strencode(oldname) # <<<<<<<<<<<<<<
* oldnamec = bytestr
* bytestr = _strencode(newname)
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_oldname, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_oldname, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2398, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2389
+ /* "netCDF4/_netCDF4.pyx":2399
* cdef char *newnamec
* bytestr = _strencode(oldname)
* oldnamec = bytestr # <<<<<<<<<<<<<<
* bytestr = _strencode(newname)
* newnamec = bytestr
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2389; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 2399, __pyx_L1_error)
__pyx_v_oldnamec = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":2390
+ /* "netCDF4/_netCDF4.pyx":2400
* bytestr = _strencode(oldname)
* oldnamec = bytestr
* bytestr = _strencode(newname) # <<<<<<<<<<<<<<
* newnamec = bytestr
* ierr = nc_rename_att(self._grpid, NC_GLOBAL, oldnamec, newnamec)
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_newname, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2390; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_newname, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2400, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF_SET(__pyx_v_bytestr, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2391
+ /* "netCDF4/_netCDF4.pyx":2401
* oldnamec = bytestr
* bytestr = _strencode(newname)
* newnamec = bytestr # <<<<<<<<<<<<<<
* ierr = nc_rename_att(self._grpid, NC_GLOBAL, oldnamec, newnamec)
* if ierr != NC_NOERR:
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2391; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 2401, __pyx_L1_error)
__pyx_v_newnamec = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":2392
+ /* "netCDF4/_netCDF4.pyx":2402
* bytestr = _strencode(newname)
* newnamec = bytestr
* ierr = nc_rename_att(self._grpid, NC_GLOBAL, oldnamec, newnamec) # <<<<<<<<<<<<<<
@@ -19019,7 +19054,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_64renameAttribute(struct _
*/
__pyx_v_ierr = nc_rename_att(__pyx_v_self->_grpid, NC_GLOBAL, __pyx_v_oldnamec, __pyx_v_newnamec);
- /* "netCDF4/_netCDF4.pyx":2393
+ /* "netCDF4/_netCDF4.pyx":2403
* newnamec = bytestr
* ierr = nc_rename_att(self._grpid, NC_GLOBAL, oldnamec, newnamec)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -19029,7 +19064,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_64renameAttribute(struct _
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2394
+ /* "netCDF4/_netCDF4.pyx":2404
* ierr = nc_rename_att(self._grpid, NC_GLOBAL, oldnamec, newnamec)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -19037,22 +19072,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_64renameAttribute(struct _
* def renameGroup(self, oldname, newname):
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2404, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2393
+ /* "netCDF4/_netCDF4.pyx":2403
* newnamec = bytestr
* ierr = nc_rename_att(self._grpid, NC_GLOBAL, oldnamec, newnamec)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -19061,7 +19096,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_64renameAttribute(struct _
*/
}
- /* "netCDF4/_netCDF4.pyx":2380
+ /* "netCDF4/_netCDF4.pyx":2390
* return self.getncattr(name)
*
* def renameAttribute(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -19084,7 +19119,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_64renameAttribute(struct _
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2396
+/* "netCDF4/_netCDF4.pyx":2406
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def renameGroup(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -19098,9 +19133,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_7Dataset_66renameGroup[] = "\n**`rename
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_67renameGroup(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
CYTHON_UNUSED PyObject *__pyx_v_oldname = 0;
CYTHON_UNUSED PyObject *__pyx_v_newname = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("renameGroup (wrapper)", 0);
@@ -19124,11 +19156,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_67renameGroup(PyObject *__
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_newname)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("renameGroup", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2396; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameGroup", 1, 2, 2, 1); __PYX_ERR(0, 2406, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameGroup") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2396; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameGroup") < 0)) __PYX_ERR(0, 2406, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -19141,7 +19173,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_7Dataset_67renameGroup(PyObject *__
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("renameGroup", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2396; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameGroup", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2406, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Dataset.renameGroup", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -19160,12 +19192,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_66renameGroup(CYTHON_UNUSE
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("renameGroup", 0);
- /* "netCDF4/_netCDF4.pyx":2418
+ /* "netCDF4/_netCDF4.pyx":2428
* self.groups[newname] = grp
* ELSE:
* msg = """ # <<<<<<<<<<<<<<
@@ -19175,26 +19204,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_66renameGroup(CYTHON_UNUSE
__Pyx_INCREF(__pyx_kp_s_renameGroup_method_not_enabled);
__pyx_v_msg = __pyx_kp_s_renameGroup_method_not_enabled;
- /* "netCDF4/_netCDF4.pyx":2421
+ /* "netCDF4/_netCDF4.pyx":2431
* renameGroup method not enabled. To enable, install Cython, make sure you have
* version 4.3.1 or higher of the netcdf C lib, and rebuild netcdf4-python."""
* raise ValueError(msg) # <<<<<<<<<<<<<<
*
* def set_auto_maskandscale(self, value):
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2421; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2431, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2421; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2431, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2421; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2431, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2396
+ /* "netCDF4/_netCDF4.pyx":2406
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def renameGroup(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -19214,7 +19243,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_66renameGroup(CYTHON_UNUSE
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2423
+/* "netCDF4/_netCDF4.pyx":2433
* raise ValueError(msg)
*
* def set_auto_maskandscale(self, value): # <<<<<<<<<<<<<<
@@ -19255,19 +19284,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
PyObject *(*__pyx_t_11)(PyObject *);
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_auto_maskandscale", 0);
- /* "netCDF4/_netCDF4.pyx":2437
+ /* "netCDF4/_netCDF4.pyx":2447
* """
*
* for var in self.variables.values(): # <<<<<<<<<<<<<<
* var.set_auto_maskandscale(value)
*
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -19280,10 +19306,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2447, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2447, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -19291,9 +19317,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2447, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -19301,17 +19327,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2447, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2447, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -19321,7 +19347,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2447, __pyx_L1_error)
}
break;
}
@@ -19330,14 +19356,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
__Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2438
+ /* "netCDF4/_netCDF4.pyx":2448
*
* for var in self.variables.values():
* var.set_auto_maskandscale(value) # <<<<<<<<<<<<<<
*
* for groups in _walk_grps(self):
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_maskandscale); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_maskandscale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -19350,23 +19376,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
}
if (!__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_value);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2437
+ /* "netCDF4/_netCDF4.pyx":2447
* """
*
* for var in self.variables.values(): # <<<<<<<<<<<<<<
@@ -19376,14 +19402,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2440
+ /* "netCDF4/_netCDF4.pyx":2450
* var.set_auto_maskandscale(value)
*
* for groups in _walk_grps(self): # <<<<<<<<<<<<<<
* for group in groups:
* for var in group.variables.values():
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_walk_grps); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_walk_grps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -19396,16 +19422,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
}
if (!__pyx_t_3) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_7, 0+1, ((PyObject *)__pyx_v_self));
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -19414,9 +19440,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
__pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2450, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -19424,17 +19450,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2450, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2450, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -19444,7 +19470,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2450, __pyx_L1_error)
}
break;
}
@@ -19453,7 +19479,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
__Pyx_XDECREF_SET(__pyx_v_groups, __pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2441
+ /* "netCDF4/_netCDF4.pyx":2451
*
* for groups in _walk_grps(self):
* for group in groups: # <<<<<<<<<<<<<<
@@ -19464,26 +19490,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
__pyx_t_2 = __pyx_v_groups; __Pyx_INCREF(__pyx_t_2); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
} else {
- __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_groups); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_groups); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2451, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_9 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2451, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_9)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 2451, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2451, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 2451, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2451, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -19493,7 +19519,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2451, __pyx_L1_error)
}
break;
}
@@ -19502,16 +19528,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
__Pyx_XDECREF_SET(__pyx_v_group, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2442
+ /* "netCDF4/_netCDF4.pyx":2452
* for groups in _walk_grps(self):
* for group in groups:
* for var in group.variables.values(): # <<<<<<<<<<<<<<
* var.set_auto_maskandscale(value)
*
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -19525,10 +19551,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
}
if (__pyx_t_3) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2452, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2452, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -19536,9 +19562,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
__pyx_t_6 = __pyx_t_7; __Pyx_INCREF(__pyx_t_6); __pyx_t_10 = 0;
__pyx_t_11 = NULL;
} else {
- __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2452, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -19546,17 +19572,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 2452, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 2452, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -19566,7 +19592,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2452, __pyx_L1_error)
}
break;
}
@@ -19575,14 +19601,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
__Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2443
+ /* "netCDF4/_netCDF4.pyx":2453
* for group in groups:
* for var in group.variables.values():
* var.set_auto_maskandscale(value) # <<<<<<<<<<<<<<
*
*
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_maskandscale); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2443; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_maskandscale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2453, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -19595,23 +19621,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
}
if (!__pyx_t_12) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2443; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2453, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2443; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2453, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_value);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2443; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2453, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2442
+ /* "netCDF4/_netCDF4.pyx":2452
* for groups in _walk_grps(self):
* for group in groups:
* for var in group.variables.values(): # <<<<<<<<<<<<<<
@@ -19621,7 +19647,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":2441
+ /* "netCDF4/_netCDF4.pyx":2451
*
* for groups in _walk_grps(self):
* for group in groups: # <<<<<<<<<<<<<<
@@ -19631,7 +19657,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2440
+ /* "netCDF4/_netCDF4.pyx":2450
* var.set_auto_maskandscale(value)
*
* for groups in _walk_grps(self): # <<<<<<<<<<<<<<
@@ -19641,7 +19667,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2423
+ /* "netCDF4/_netCDF4.pyx":2433
* raise ValueError(msg)
*
* def set_auto_maskandscale(self, value): # <<<<<<<<<<<<<<
@@ -19671,7 +19697,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_68set_auto_maskandscale(st
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2446
+/* "netCDF4/_netCDF4.pyx":2456
*
*
* def set_auto_mask(self, value): # <<<<<<<<<<<<<<
@@ -19712,19 +19738,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
PyObject *(*__pyx_t_11)(PyObject *);
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_auto_mask", 0);
- /* "netCDF4/_netCDF4.pyx":2460
+ /* "netCDF4/_netCDF4.pyx":2470
* """
*
* for var in self.variables.values(): # <<<<<<<<<<<<<<
* var.set_auto_mask(value)
*
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2470, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -19737,10 +19760,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2470, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2470, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -19748,9 +19771,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2470, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2470, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -19758,17 +19781,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2470, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2470, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2470, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2470, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -19778,7 +19801,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2470, __pyx_L1_error)
}
break;
}
@@ -19787,14 +19810,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
__Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2461
+ /* "netCDF4/_netCDF4.pyx":2471
*
* for var in self.variables.values():
* var.set_auto_mask(value) # <<<<<<<<<<<<<<
*
* for groups in _walk_grps(self):
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_mask); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2461; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_mask); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2471, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -19807,23 +19830,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
}
if (!__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2461; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2471, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2461; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2471, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_value);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2461; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2471, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2460
+ /* "netCDF4/_netCDF4.pyx":2470
* """
*
* for var in self.variables.values(): # <<<<<<<<<<<<<<
@@ -19833,14 +19856,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2463
+ /* "netCDF4/_netCDF4.pyx":2473
* var.set_auto_mask(value)
*
* for groups in _walk_grps(self): # <<<<<<<<<<<<<<
* for group in groups:
* for var in group.variables.values():
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_walk_grps); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_walk_grps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -19853,16 +19876,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
}
if (!__pyx_t_3) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_7, 0+1, ((PyObject *)__pyx_v_self));
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -19871,9 +19894,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
__pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2473, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -19881,17 +19904,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2473, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2473, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -19901,7 +19924,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2473, __pyx_L1_error)
}
break;
}
@@ -19910,7 +19933,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
__Pyx_XDECREF_SET(__pyx_v_groups, __pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2464
+ /* "netCDF4/_netCDF4.pyx":2474
*
* for groups in _walk_grps(self):
* for group in groups: # <<<<<<<<<<<<<<
@@ -19921,26 +19944,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
__pyx_t_2 = __pyx_v_groups; __Pyx_INCREF(__pyx_t_2); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
} else {
- __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_groups); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_groups); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_9 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2474, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_9)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 2474, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 2474, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -19950,7 +19973,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2474, __pyx_L1_error)
}
break;
}
@@ -19959,16 +19982,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
__Pyx_XDECREF_SET(__pyx_v_group, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2465
+ /* "netCDF4/_netCDF4.pyx":2475
* for groups in _walk_grps(self):
* for group in groups:
* for var in group.variables.values(): # <<<<<<<<<<<<<<
* var.set_auto_mask(value)
*
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2475, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2475, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -19982,10 +20005,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
}
if (__pyx_t_3) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2475, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2475, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -19993,9 +20016,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
__pyx_t_6 = __pyx_t_7; __Pyx_INCREF(__pyx_t_6); __pyx_t_10 = 0;
__pyx_t_11 = NULL;
} else {
- __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2475, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2475, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -20003,17 +20026,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 2475, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2475, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 2475, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2475, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -20023,7 +20046,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2475, __pyx_L1_error)
}
break;
}
@@ -20032,14 +20055,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
__Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2466
+ /* "netCDF4/_netCDF4.pyx":2476
* for group in groups:
* for var in group.variables.values():
* var.set_auto_mask(value) # <<<<<<<<<<<<<<
*
* def set_auto_scale(self, value):
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_mask); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_mask); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2476, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -20052,23 +20075,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
}
if (!__pyx_t_12) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2476, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2476, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_value);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2476, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2465
+ /* "netCDF4/_netCDF4.pyx":2475
* for groups in _walk_grps(self):
* for group in groups:
* for var in group.variables.values(): # <<<<<<<<<<<<<<
@@ -20078,7 +20101,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":2464
+ /* "netCDF4/_netCDF4.pyx":2474
*
* for groups in _walk_grps(self):
* for group in groups: # <<<<<<<<<<<<<<
@@ -20088,7 +20111,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2463
+ /* "netCDF4/_netCDF4.pyx":2473
* var.set_auto_mask(value)
*
* for groups in _walk_grps(self): # <<<<<<<<<<<<<<
@@ -20098,7 +20121,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2446
+ /* "netCDF4/_netCDF4.pyx":2456
*
*
* def set_auto_mask(self, value): # <<<<<<<<<<<<<<
@@ -20128,7 +20151,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_70set_auto_mask(struct __p
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2468
+/* "netCDF4/_netCDF4.pyx":2478
* var.set_auto_mask(value)
*
* def set_auto_scale(self, value): # <<<<<<<<<<<<<<
@@ -20169,19 +20192,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
PyObject *(*__pyx_t_11)(PyObject *);
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_auto_scale", 0);
- /* "netCDF4/_netCDF4.pyx":2482
+ /* "netCDF4/_netCDF4.pyx":2492
* """
*
* for var in self.variables.values(): # <<<<<<<<<<<<<<
* var.set_auto_scale(value)
*
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->variables, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -20194,10 +20214,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2492, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2492, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -20205,9 +20225,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2492, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -20215,17 +20235,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2492, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2492, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -20235,7 +20255,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2482; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2492, __pyx_L1_error)
}
break;
}
@@ -20244,14 +20264,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
__Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2483
+ /* "netCDF4/_netCDF4.pyx":2493
*
* for var in self.variables.values():
* var.set_auto_scale(value) # <<<<<<<<<<<<<<
*
* for groups in _walk_grps(self):
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_scale); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2483; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_scale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2493, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -20264,23 +20284,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
}
if (!__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2483; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2493, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2483; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2493, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_value);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2483; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2493, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2482
+ /* "netCDF4/_netCDF4.pyx":2492
* """
*
* for var in self.variables.values(): # <<<<<<<<<<<<<<
@@ -20290,14 +20310,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2485
+ /* "netCDF4/_netCDF4.pyx":2495
* var.set_auto_scale(value)
*
* for groups in _walk_grps(self): # <<<<<<<<<<<<<<
* for group in groups:
* for var in group.variables.values():
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_walk_grps); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_walk_grps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -20310,16 +20330,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
}
if (!__pyx_t_3) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_7, 0+1, ((PyObject *)__pyx_v_self));
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -20328,9 +20348,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
__pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2495, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -20338,17 +20358,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2495, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 2495, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -20358,7 +20378,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2495, __pyx_L1_error)
}
break;
}
@@ -20367,7 +20387,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
__Pyx_XDECREF_SET(__pyx_v_groups, __pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2486
+ /* "netCDF4/_netCDF4.pyx":2496
*
* for groups in _walk_grps(self):
* for group in groups: # <<<<<<<<<<<<<<
@@ -20378,26 +20398,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
__pyx_t_2 = __pyx_v_groups; __Pyx_INCREF(__pyx_t_2); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
} else {
- __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_groups); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_groups); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2496, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_9 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2496, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_9)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 2496, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2496, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 2496, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_2, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2496, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -20407,7 +20427,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2496, __pyx_L1_error)
}
break;
}
@@ -20416,16 +20436,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
__Pyx_XDECREF_SET(__pyx_v_group, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2487
+ /* "netCDF4/_netCDF4.pyx":2497
* for groups in _walk_grps(self):
* for group in groups:
* for var in group.variables.values(): # <<<<<<<<<<<<<<
* var.set_auto_scale(value)
*
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -20439,10 +20459,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
}
if (__pyx_t_3) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2497, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2497, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -20450,9 +20470,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
__pyx_t_6 = __pyx_t_7; __Pyx_INCREF(__pyx_t_6); __pyx_t_10 = 0;
__pyx_t_11 = NULL;
} else {
- __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2497, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -20460,17 +20480,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 2497, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 2497, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -20480,7 +20500,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2487; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2497, __pyx_L1_error)
}
break;
}
@@ -20489,14 +20509,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
__Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2488
+ /* "netCDF4/_netCDF4.pyx":2498
* for group in groups:
* for var in group.variables.values():
* var.set_auto_scale(value) # <<<<<<<<<<<<<<
*
* def get_variables_by_attributes(self, **kwargs):
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_scale); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2488; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_set_auto_scale); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2498, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -20509,23 +20529,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
}
if (!__pyx_t_12) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2488; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_value); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2498, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2488; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 2498, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_value);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2488; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2498, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":2487
+ /* "netCDF4/_netCDF4.pyx":2497
* for groups in _walk_grps(self):
* for group in groups:
* for var in group.variables.values(): # <<<<<<<<<<<<<<
@@ -20535,7 +20555,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":2486
+ /* "netCDF4/_netCDF4.pyx":2496
*
* for groups in _walk_grps(self):
* for group in groups: # <<<<<<<<<<<<<<
@@ -20545,7 +20565,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2485
+ /* "netCDF4/_netCDF4.pyx":2495
* var.set_auto_scale(value)
*
* for groups in _walk_grps(self): # <<<<<<<<<<<<<<
@@ -20555,7 +20575,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2468
+ /* "netCDF4/_netCDF4.pyx":2478
* var.set_auto_mask(value)
*
* def set_auto_scale(self, value): # <<<<<<<<<<<<<<
@@ -20585,7 +20605,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_72set_auto_scale(struct __
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2490
+/* "netCDF4/_netCDF4.pyx":2500
* var.set_auto_scale(value)
*
* def get_variables_by_attributes(self, **kwargs): # <<<<<<<<<<<<<<
@@ -20639,24 +20659,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
PyObject *__pyx_t_14 = NULL;
int __pyx_t_15;
int __pyx_t_16;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_variables_by_attributes", 0);
- /* "netCDF4/_netCDF4.pyx":2518
+ /* "netCDF4/_netCDF4.pyx":2528
* >>> vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None)
* """
* vs = [] # <<<<<<<<<<<<<<
*
* has_value_flag = False
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_vs = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2520
+ /* "netCDF4/_netCDF4.pyx":2530
* vs = []
*
* has_value_flag = False # <<<<<<<<<<<<<<
@@ -20666,7 +20683,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_INCREF(Py_False);
__pyx_v_has_value_flag = Py_False;
- /* "netCDF4/_netCDF4.pyx":2521
+ /* "netCDF4/_netCDF4.pyx":2531
*
* has_value_flag = False
* for vname in self.variables: # <<<<<<<<<<<<<<
@@ -20677,26 +20694,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__pyx_t_1 = __pyx_v_self->variables; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
__pyx_t_3 = NULL;
} else {
- __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_self->variables); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2521; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_self->variables); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2531, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2521; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2531, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_3)) {
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2521; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 2531, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2521; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2531, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2521; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 2531, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2521; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2531, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -20706,7 +20723,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2521; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2531, __pyx_L1_error)
}
break;
}
@@ -20715,34 +20732,34 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_XDECREF_SET(__pyx_v_vname, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":2522
+ /* "netCDF4/_netCDF4.pyx":2532
* has_value_flag = False
* for vname in self.variables:
* var = self.variables[vname] # <<<<<<<<<<<<<<
* for k, v in kwargs.items():
* if callable(v):
*/
- __pyx_t_4 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_vname); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2522; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_vname); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2532, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_var, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":2523
+ /* "netCDF4/_netCDF4.pyx":2533
* for vname in self.variables:
* var = self.variables[vname]
* for k, v in kwargs.items(): # <<<<<<<<<<<<<<
* if callable(v):
* has_value_flag = v(getattr(var, k, None))
*/
- __pyx_t_4 = __Pyx_PyDict_Items(__pyx_v_kwargs); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyDict_Items(__pyx_v_kwargs); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
__pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2533, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
for (;;) {
@@ -20750,17 +20767,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
if (likely(PyList_CheckExact(__pyx_t_5))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 2533, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_4); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 2533, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -20770,7 +20787,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 2533, __pyx_L1_error)
}
break;
}
@@ -20786,7 +20803,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2533, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -20799,15 +20816,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(__pyx_t_9);
#else
- __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
#endif
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_10 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2533, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_10)->tp_iternext;
@@ -20815,7 +20832,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_GOTREF(__pyx_t_8);
index = 1; __pyx_t_9 = __pyx_t_11(__pyx_t_10); if (unlikely(!__pyx_t_9)) goto __pyx_L7_unpacking_failed;
__Pyx_GOTREF(__pyx_t_9);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 2) < 0) __PYX_ERR(0, 2533, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
goto __pyx_L8_unpacking_done;
@@ -20823,7 +20840,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2533, __pyx_L1_error)
__pyx_L8_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_k, __pyx_t_8);
@@ -20831,25 +20848,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_9);
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":2524
+ /* "netCDF4/_netCDF4.pyx":2534
* var = self.variables[vname]
* for k, v in kwargs.items():
* if callable(v): # <<<<<<<<<<<<<<
* has_value_flag = v(getattr(var, k, None))
* if has_value_flag is False:
*/
- __pyx_t_12 = __Pyx_PyCallable_Check(__pyx_v_v); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2524; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyCallable_Check(__pyx_v_v); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 2534, __pyx_L1_error)
__pyx_t_13 = (__pyx_t_12 != 0);
if (__pyx_t_13) {
- /* "netCDF4/_netCDF4.pyx":2525
+ /* "netCDF4/_netCDF4.pyx":2535
* for k, v in kwargs.items():
* if callable(v):
* has_value_flag = v(getattr(var, k, None)) # <<<<<<<<<<<<<<
* if has_value_flag is False:
* break
*/
- __pyx_t_9 = __Pyx_GetAttr3(__pyx_v_var, __pyx_v_k, Py_None); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetAttr3(__pyx_v_var, __pyx_v_k, Py_None); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2535, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_INCREF(__pyx_v_v);
__pyx_t_8 = __pyx_v_v; __pyx_t_10 = NULL;
@@ -20863,17 +20880,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
}
}
if (!__pyx_t_10) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2535, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else {
- __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 2535, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_10); __pyx_t_10 = NULL;
__Pyx_GIVEREF(__pyx_t_9);
PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_t_9);
__pyx_t_9 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_14, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2535, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
}
@@ -20881,7 +20898,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_DECREF_SET(__pyx_v_has_value_flag, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":2526
+ /* "netCDF4/_netCDF4.pyx":2536
* if callable(v):
* has_value_flag = v(getattr(var, k, None))
* if has_value_flag is False: # <<<<<<<<<<<<<<
@@ -20892,7 +20909,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__pyx_t_12 = (__pyx_t_13 != 0);
if (__pyx_t_12) {
- /* "netCDF4/_netCDF4.pyx":2527
+ /* "netCDF4/_netCDF4.pyx":2537
* has_value_flag = v(getattr(var, k, None))
* if has_value_flag is False:
* break # <<<<<<<<<<<<<<
@@ -20901,7 +20918,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
*/
goto __pyx_L6_break;
- /* "netCDF4/_netCDF4.pyx":2526
+ /* "netCDF4/_netCDF4.pyx":2536
* if callable(v):
* has_value_flag = v(getattr(var, k, None))
* if has_value_flag is False: # <<<<<<<<<<<<<<
@@ -20910,7 +20927,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
*/
}
- /* "netCDF4/_netCDF4.pyx":2524
+ /* "netCDF4/_netCDF4.pyx":2534
* var = self.variables[vname]
* for k, v in kwargs.items():
* if callable(v): # <<<<<<<<<<<<<<
@@ -20920,31 +20937,31 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":2528
+ /* "netCDF4/_netCDF4.pyx":2538
* if has_value_flag is False:
* break
* elif hasattr(var, k) and getattr(var, k) == v: # <<<<<<<<<<<<<<
* has_value_flag = True
* else:
*/
- __pyx_t_13 = PyObject_HasAttr(__pyx_v_var, __pyx_v_k); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2528; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = PyObject_HasAttr(__pyx_v_var, __pyx_v_k); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 2538, __pyx_L1_error)
__pyx_t_15 = (__pyx_t_13 != 0);
if (__pyx_t_15) {
} else {
__pyx_t_12 = __pyx_t_15;
goto __pyx_L11_bool_binop_done;
}
- __pyx_t_4 = __Pyx_GetAttr(__pyx_v_var, __pyx_v_k); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2528; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetAttr(__pyx_v_var, __pyx_v_k); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2538, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_8 = PyObject_RichCompare(__pyx_t_4, __pyx_v_v, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2528; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_RichCompare(__pyx_t_4, __pyx_v_v, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2538, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_15 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2528; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_15 < 0)) __PYX_ERR(0, 2538, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_12 = __pyx_t_15;
__pyx_L11_bool_binop_done:;
if (__pyx_t_12) {
- /* "netCDF4/_netCDF4.pyx":2529
+ /* "netCDF4/_netCDF4.pyx":2539
* break
* elif hasattr(var, k) and getattr(var, k) == v:
* has_value_flag = True # <<<<<<<<<<<<<<
@@ -20954,7 +20971,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_INCREF(Py_True);
__Pyx_DECREF_SET(__pyx_v_has_value_flag, Py_True);
- /* "netCDF4/_netCDF4.pyx":2528
+ /* "netCDF4/_netCDF4.pyx":2538
* if has_value_flag is False:
* break
* elif hasattr(var, k) and getattr(var, k) == v: # <<<<<<<<<<<<<<
@@ -20964,7 +20981,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":2531
+ /* "netCDF4/_netCDF4.pyx":2541
* has_value_flag = True
* else:
* has_value_flag = False # <<<<<<<<<<<<<<
@@ -20975,7 +20992,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__Pyx_INCREF(Py_False);
__Pyx_DECREF_SET(__pyx_v_has_value_flag, Py_False);
- /* "netCDF4/_netCDF4.pyx":2532
+ /* "netCDF4/_netCDF4.pyx":2542
* else:
* has_value_flag = False
* break # <<<<<<<<<<<<<<
@@ -20986,7 +21003,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
}
__pyx_L9:;
- /* "netCDF4/_netCDF4.pyx":2523
+ /* "netCDF4/_netCDF4.pyx":2533
* for vname in self.variables:
* var = self.variables[vname]
* for k, v in kwargs.items(): # <<<<<<<<<<<<<<
@@ -20997,7 +21014,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__pyx_L6_break:;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":2534
+ /* "netCDF4/_netCDF4.pyx":2544
* break
*
* if has_value_flag is True: # <<<<<<<<<<<<<<
@@ -21008,19 +21025,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__pyx_t_15 = (__pyx_t_12 != 0);
if (__pyx_t_15) {
- /* "netCDF4/_netCDF4.pyx":2535
+ /* "netCDF4/_netCDF4.pyx":2545
*
* if has_value_flag is True:
* vs.append(self.variables[vname]) # <<<<<<<<<<<<<<
*
* return vs
*/
- __pyx_t_5 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_vname); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2535; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = PyObject_GetItem(__pyx_v_self->variables, __pyx_v_vname); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2545, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_16 = __Pyx_PyList_Append(__pyx_v_vs, __pyx_t_5); if (unlikely(__pyx_t_16 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2535; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_16 = __Pyx_PyList_Append(__pyx_v_vs, __pyx_t_5); if (unlikely(__pyx_t_16 == -1)) __PYX_ERR(0, 2545, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":2534
+ /* "netCDF4/_netCDF4.pyx":2544
* break
*
* if has_value_flag is True: # <<<<<<<<<<<<<<
@@ -21029,7 +21046,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
*/
}
- /* "netCDF4/_netCDF4.pyx":2521
+ /* "netCDF4/_netCDF4.pyx":2531
*
* has_value_flag = False
* for vname in self.variables: # <<<<<<<<<<<<<<
@@ -21039,7 +21056,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2537
+ /* "netCDF4/_netCDF4.pyx":2547
* vs.append(self.variables[vname])
*
* return vs # <<<<<<<<<<<<<<
@@ -21051,7 +21068,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
__pyx_r = __pyx_v_vs;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2490
+ /* "netCDF4/_netCDF4.pyx":2500
* var.set_auto_scale(value)
*
* def get_variables_by_attributes(self, **kwargs): # <<<<<<<<<<<<<<
@@ -21082,7 +21099,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_74get_variables_by_attribu
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1613
+/* "netCDF4/_netCDF4.pyx":1623
* """
* cdef object __weakref__
* cdef public int _grpid # <<<<<<<<<<<<<<
@@ -21107,12 +21124,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_6_grpid___get__(struct __p
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1623, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -21146,11 +21160,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_6_grpid_2__set__(struct __pyx_ob
int __pyx_r;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1623, __pyx_L1_error)
__pyx_v_self->_grpid = __pyx_t_1;
/* function exit code */
@@ -21164,7 +21175,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_6_grpid_2__set__(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1614
+/* "netCDF4/_netCDF4.pyx":1624
* cdef object __weakref__
* cdef public int _grpid
* cdef public int _isopen # <<<<<<<<<<<<<<
@@ -21189,12 +21200,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_7Dataset_7_isopen___get__(struct __
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_isopen); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1614; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_isopen); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1624, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -21228,11 +21236,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_7_isopen_2__set__(struct __pyx_o
int __pyx_r;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1614; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1624, __pyx_L1_error)
__pyx_v_self->_isopen = __pyx_t_1;
/* function exit code */
@@ -21246,7 +21251,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_7_isopen_2__set__(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1615
+/* "netCDF4/_netCDF4.pyx":1625
* cdef public int _grpid
* cdef public int _isopen
* cdef public groups, dimensions, variables, disk_format, path, parent,\ # <<<<<<<<<<<<<<
@@ -21776,7 +21781,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_6parent_4__del__(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1616
+/* "netCDF4/_netCDF4.pyx":1626
* cdef public int _isopen
* cdef public groups, dimensions, variables, disk_format, path, parent,\
* file_format, data_model, cmptypes, vltypes, enumtypes, __orthogonal_indexing__, \ # <<<<<<<<<<<<<<
@@ -22306,7 +22311,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_23__orthogonal_indexing___4__del
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":1617
+/* "netCDF4/_netCDF4.pyx":1627
* cdef public groups, dimensions, variables, disk_format, path, parent,\
* file_format, data_model, cmptypes, vltypes, enumtypes, __orthogonal_indexing__, \
* keepweakref # <<<<<<<<<<<<<<
@@ -22401,7 +22406,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_7Dataset_11keepweakref_4__del__(struct __
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2559
+/* "netCDF4/_netCDF4.pyx":2569
* __pdoc__['Group.name']=\
* """A string describing the name of the `netCDF4.Group`."""
* def __init__(self, parent, name, **kwargs): # <<<<<<<<<<<<<<
@@ -22419,9 +22424,6 @@ static int __pyx_pw_7netCDF4_8_netCDF4_5Group_1__init__(PyObject *__pyx_v_self,
PyObject *__pyx_v_parent = 0;
PyObject *__pyx_v_name = 0;
PyObject *__pyx_v_kwargs = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -22447,11 +22449,11 @@ static int __pyx_pw_7netCDF4_8_netCDF4_5Group_1__init__(PyObject *__pyx_v_self,
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2559; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 2569, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2559; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 2569, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -22464,7 +22466,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_5Group_1__init__(PyObject *__pyx_v_self,
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2559; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2569, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("netCDF4._netCDF4.Group.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
@@ -22496,12 +22498,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
int __pyx_t_9;
PyObject *(*__pyx_t_10)(PyObject *);
char *__pyx_t_11;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
- /* "netCDF4/_netCDF4.pyx":2576
+ /* "netCDF4/_netCDF4.pyx":2586
* cdef char *groupname
* # flag to indicate that Variables in this Group support orthogonal indexing.
* self.__orthogonal_indexing__ = True # <<<<<<<<<<<<<<
@@ -22514,14 +22513,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__Pyx_DECREF(__pyx_v_self->__pyx_base.__orthogonal_indexing__);
__pyx_v_self->__pyx_base.__orthogonal_indexing__ = Py_True;
- /* "netCDF4/_netCDF4.pyx":2578
+ /* "netCDF4/_netCDF4.pyx":2588
* self.__orthogonal_indexing__ = True
* # set data_model and file_format attributes.
* self.data_model = parent.data_model # <<<<<<<<<<<<<<
* self.file_format = parent.file_format
* # full path to Group.
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2578; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2588, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->__pyx_base.data_model);
@@ -22529,14 +22528,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.data_model = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2579
+ /* "netCDF4/_netCDF4.pyx":2589
* # set data_model and file_format attributes.
* self.data_model = parent.data_model
* self.file_format = parent.file_format # <<<<<<<<<<<<<<
* # full path to Group.
* self.path = posixpath.join(parent.path, name)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_file_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2579; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_file_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2589, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->__pyx_base.file_format);
@@ -22544,19 +22543,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.file_format = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2581
+ /* "netCDF4/_netCDF4.pyx":2591
* self.file_format = parent.file_format
* # full path to Group.
* self.path = posixpath.join(parent.path, name) # <<<<<<<<<<<<<<
* # parent group.
* self.parent = parent
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_posixpath); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_join); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_join); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
__pyx_t_5 = 0;
@@ -22570,7 +22569,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_t_5 = 1;
}
}
- __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -22581,7 +22580,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_name);
__pyx_t_2 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -22591,7 +22590,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.path = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2583
+ /* "netCDF4/_netCDF4.pyx":2593
* self.path = posixpath.join(parent.path, name)
* # parent group.
* self.parent = parent # <<<<<<<<<<<<<<
@@ -22604,14 +22603,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__Pyx_DECREF(__pyx_v_self->__pyx_base.parent);
__pyx_v_self->__pyx_base.parent = __pyx_v_parent;
- /* "netCDF4/_netCDF4.pyx":2585
+ /* "netCDF4/_netCDF4.pyx":2595
* self.parent = parent
* # propagate weak reference setting from parent.
* self.keepweakref = parent.keepweakref # <<<<<<<<<<<<<<
* if 'id' in kwargs:
* self._grpid = kwargs['id']
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_keepweakref); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2585; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_keepweakref); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2595, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->__pyx_base.keepweakref);
@@ -22619,38 +22618,38 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.keepweakref = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2586
+ /* "netCDF4/_netCDF4.pyx":2596
* # propagate weak reference setting from parent.
* self.keepweakref = parent.keepweakref
* if 'id' in kwargs: # <<<<<<<<<<<<<<
* self._grpid = kwargs['id']
* # get compound, vlen and enum types in this Group.
*/
- __pyx_t_7 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_id, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2586; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_id, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 2596, __pyx_L1_error)
__pyx_t_8 = (__pyx_t_7 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":2587
+ /* "netCDF4/_netCDF4.pyx":2597
* self.keepweakref = parent.keepweakref
* if 'id' in kwargs:
* self._grpid = kwargs['id'] # <<<<<<<<<<<<<<
* # get compound, vlen and enum types in this Group.
* self.cmptypes, self.vltypes, self.enumtypes = _get_types(self)
*/
- __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_id); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2587; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2597, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2587; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2597, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_self->__pyx_base._grpid = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":2589
+ /* "netCDF4/_netCDF4.pyx":2599
* self._grpid = kwargs['id']
* # get compound, vlen and enum types in this Group.
* self.cmptypes, self.vltypes, self.enumtypes = _get_types(self) # <<<<<<<<<<<<<<
* # get dimensions in this Group.
* self.dimensions = _get_dims(self)
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_types(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_types(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
PyObject* sequence = __pyx_t_1;
@@ -22662,7 +22661,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
if (unlikely(size != 3)) {
if (size > 3) __Pyx_RaiseTooManyValuesError(3);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2599, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -22678,17 +22677,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_2);
#else
- __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext;
@@ -22698,7 +22697,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__Pyx_GOTREF(__pyx_t_6);
index = 2; __pyx_t_2 = __pyx_t_10(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L4_unpacking_failed;
__Pyx_GOTREF(__pyx_t_2);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_4), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_4), 3) < 0) __PYX_ERR(0, 2599, __pyx_L1_error)
__pyx_t_10 = NULL;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L5_unpacking_done;
@@ -22706,7 +22705,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_10 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2599, __pyx_L1_error)
__pyx_L5_unpacking_done:;
}
__Pyx_GIVEREF(__pyx_t_3);
@@ -22725,14 +22724,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.enumtypes = __pyx_t_2;
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":2591
+ /* "netCDF4/_netCDF4.pyx":2601
* self.cmptypes, self.vltypes, self.enumtypes = _get_types(self)
* # get dimensions in this Group.
* self.dimensions = _get_dims(self) # <<<<<<<<<<<<<<
* # get variables in this Group.
* self.variables = _get_vars(self)
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_dims(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2591; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_dims(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2601, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->__pyx_base.dimensions);
@@ -22740,14 +22739,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.dimensions = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2593
+ /* "netCDF4/_netCDF4.pyx":2603
* self.dimensions = _get_dims(self)
* # get variables in this Group.
* self.variables = _get_vars(self) # <<<<<<<<<<<<<<
* # get groups in this Group.
* self.groups = _get_grps(self)
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_vars(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2593; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_vars(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2603, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->__pyx_base.variables);
@@ -22755,14 +22754,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.variables = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2595
+ /* "netCDF4/_netCDF4.pyx":2605
* self.variables = _get_vars(self)
* # get groups in this Group.
* self.groups = _get_grps(self) # <<<<<<<<<<<<<<
* else:
* bytestr = _strencode(name)
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_grps(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2595; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_grps(((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->__pyx_base.groups);
@@ -22770,7 +22769,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.groups = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2586
+ /* "netCDF4/_netCDF4.pyx":2596
* # propagate weak reference setting from parent.
* self.keepweakref = parent.keepweakref
* if 'id' in kwargs: # <<<<<<<<<<<<<<
@@ -22780,7 +22779,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":2597
+ /* "netCDF4/_netCDF4.pyx":2607
* self.groups = _get_grps(self)
* else:
* bytestr = _strencode(name) # <<<<<<<<<<<<<<
@@ -22788,35 +22787,35 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
* ierr = nc_def_grp(parent._grpid, groupname, &self._grpid)
*/
/*else*/ {
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2597; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2607, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2598
+ /* "netCDF4/_netCDF4.pyx":2608
* else:
* bytestr = _strencode(name)
* groupname = bytestr # <<<<<<<<<<<<<<
* ierr = nc_def_grp(parent._grpid, groupname, &self._grpid)
* if ierr != NC_NOERR:
*/
- __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2598; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) __PYX_ERR(0, 2608, __pyx_L1_error)
__pyx_v_groupname = __pyx_t_11;
- /* "netCDF4/_netCDF4.pyx":2599
+ /* "netCDF4/_netCDF4.pyx":2609
* bytestr = _strencode(name)
* groupname = bytestr
* ierr = nc_def_grp(parent._grpid, groupname, &self._grpid) # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2599; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_parent, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2599; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2609, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_ierr = nc_def_grp(__pyx_t_9, __pyx_v_groupname, (&__pyx_v_self->__pyx_base._grpid));
- /* "netCDF4/_netCDF4.pyx":2600
+ /* "netCDF4/_netCDF4.pyx":2610
* groupname = bytestr
* ierr = nc_def_grp(parent._grpid, groupname, &self._grpid)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -22826,7 +22825,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_t_8 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":2601
+ /* "netCDF4/_netCDF4.pyx":2611
* ierr = nc_def_grp(parent._grpid, groupname, &self._grpid)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -22834,22 +22833,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
* self.vltypes = OrderedDict()
*/
__pyx_t_11 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_11, 0, strlen(__pyx_t_11), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2601; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_11, 0, strlen(__pyx_t_11), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2601; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2601; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2601; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2611, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2600
+ /* "netCDF4/_netCDF4.pyx":2610
* groupname = bytestr
* ierr = nc_def_grp(parent._grpid, groupname, &self._grpid)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -22858,14 +22857,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
*/
}
- /* "netCDF4/_netCDF4.pyx":2602
+ /* "netCDF4/_netCDF4.pyx":2612
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* self.cmptypes = OrderedDict() # <<<<<<<<<<<<<<
* self.vltypes = OrderedDict()
* self.enumtypes = OrderedDict()
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2612, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -22878,10 +22877,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2612, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2612, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -22891,14 +22890,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.cmptypes = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2603
+ /* "netCDF4/_netCDF4.pyx":2613
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* self.cmptypes = OrderedDict()
* self.vltypes = OrderedDict() # <<<<<<<<<<<<<<
* self.enumtypes = OrderedDict()
* self.dimensions = OrderedDict()
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2603; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2613, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -22911,10 +22910,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2603; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2613, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2603; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2613, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -22924,14 +22923,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.vltypes = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2604
+ /* "netCDF4/_netCDF4.pyx":2614
* self.cmptypes = OrderedDict()
* self.vltypes = OrderedDict()
* self.enumtypes = OrderedDict() # <<<<<<<<<<<<<<
* self.dimensions = OrderedDict()
* self.variables = OrderedDict()
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2604; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -22944,10 +22943,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2604; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2614, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2604; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2614, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -22957,14 +22956,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.enumtypes = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2605
+ /* "netCDF4/_netCDF4.pyx":2615
* self.vltypes = OrderedDict()
* self.enumtypes = OrderedDict()
* self.dimensions = OrderedDict() # <<<<<<<<<<<<<<
* self.variables = OrderedDict()
* self.groups = OrderedDict()
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2615, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -22977,10 +22976,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2615, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2615, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -22990,14 +22989,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.dimensions = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2606
+ /* "netCDF4/_netCDF4.pyx":2616
* self.enumtypes = OrderedDict()
* self.dimensions = OrderedDict()
* self.variables = OrderedDict() # <<<<<<<<<<<<<<
* self.groups = OrderedDict()
*
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2606; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -23010,10 +23009,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2606; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2616, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2606; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2616, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -23023,14 +23022,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
__pyx_v_self->__pyx_base.variables = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2607
+ /* "netCDF4/_netCDF4.pyx":2617
* self.dimensions = OrderedDict()
* self.variables = OrderedDict()
* self.groups = OrderedDict() # <<<<<<<<<<<<<<
*
* def close(self):
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2617, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -23043,10 +23042,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2617, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2617, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -23058,7 +23057,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":2559
+ /* "netCDF4/_netCDF4.pyx":2569
* __pdoc__['Group.name']=\
* """A string describing the name of the `netCDF4.Group`."""
* def __init__(self, parent, name, **kwargs): # <<<<<<<<<<<<<<
@@ -23083,7 +23082,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group___init__(struct __pyx_obj_7netCDF4
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2609
+/* "netCDF4/_netCDF4.pyx":2619
* self.groups = OrderedDict()
*
* def close(self): # <<<<<<<<<<<<<<
@@ -23109,25 +23108,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_2close(CYTHON_UNUSED struct
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("close", 0);
- /* "netCDF4/_netCDF4.pyx":2615
+ /* "netCDF4/_netCDF4.pyx":2625
* overrides `netCDF4.Dataset` close method which does not apply to `netCDF4.Group`
* instances, raises IOError."""
* raise IOError('cannot close a `netCDF4.Group` (only applies to Dataset)') # <<<<<<<<<<<<<<
*
* def _getname(self):
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2615; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2625, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2615; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2625, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2609
+ /* "netCDF4/_netCDF4.pyx":2619
* self.groups = OrderedDict()
*
* def close(self): # <<<<<<<<<<<<<<
@@ -23145,7 +23141,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_2close(CYTHON_UNUSED struct
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2617
+/* "netCDF4/_netCDF4.pyx":2627
* raise IOError('cannot close a `netCDF4.Group` (only applies to Dataset)')
*
* def _getname(self): # <<<<<<<<<<<<<<
@@ -23180,12 +23176,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
PyObject *__pyx_t_7 = NULL;
Py_ssize_t __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_getname", 0);
- /* "netCDF4/_netCDF4.pyx":2621
+ /* "netCDF4/_netCDF4.pyx":2631
* cdef int err
* cdef char namstring[NC_MAX_NAME+1]
* with nogil: # <<<<<<<<<<<<<<
@@ -23199,7 +23192,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":2622
+ /* "netCDF4/_netCDF4.pyx":2632
* cdef char namstring[NC_MAX_NAME+1]
* with nogil:
* ierr = nc_inq_grpname(self._grpid, namstring) # <<<<<<<<<<<<<<
@@ -23209,7 +23202,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
__pyx_v_ierr = nc_inq_grpname(__pyx_v_self->__pyx_base._grpid, __pyx_v_namstring);
}
- /* "netCDF4/_netCDF4.pyx":2621
+ /* "netCDF4/_netCDF4.pyx":2631
* cdef int err
* cdef char namstring[NC_MAX_NAME+1]
* with nogil: # <<<<<<<<<<<<<<
@@ -23227,7 +23220,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
}
}
- /* "netCDF4/_netCDF4.pyx":2623
+ /* "netCDF4/_netCDF4.pyx":2633
* with nogil:
* ierr = nc_inq_grpname(self._grpid, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -23237,7 +23230,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2624
+ /* "netCDF4/_netCDF4.pyx":2634
* ierr = nc_inq_grpname(self._grpid, namstring)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -23245,22 +23238,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
*
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2624; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2624; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2624; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2624; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2634, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2623
+ /* "netCDF4/_netCDF4.pyx":2633
* with nogil:
* ierr = nc_inq_grpname(self._grpid, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -23269,7 +23262,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":2625
+ /* "netCDF4/_netCDF4.pyx":2635
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* return namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
@@ -23277,14 +23270,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
* property name:
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_4 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2635, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2635, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2635, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2635, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
__pyx_t_8 = 0;
@@ -23298,7 +23291,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
__pyx_t_8 = 1;
}
}
- __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2635, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -23309,7 +23302,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6);
__pyx_t_4 = 0;
__pyx_t_6 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2635, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -23317,7 +23310,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
__pyx_t_3 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2617
+ /* "netCDF4/_netCDF4.pyx":2627
* raise IOError('cannot close a `netCDF4.Group` (only applies to Dataset)')
*
* def _getname(self): # <<<<<<<<<<<<<<
@@ -23341,7 +23334,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4_getname(struct __pyx_obj_7
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2629
+/* "netCDF4/_netCDF4.pyx":2639
* property name:
* """string name of Group instance"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -23368,12 +23361,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4name___get__(struct __pyx_o
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
- /* "netCDF4/_netCDF4.pyx":2630
+ /* "netCDF4/_netCDF4.pyx":2640
* """string name of Group instance"""
* def __get__(self):
* return self._getname() # <<<<<<<<<<<<<<
@@ -23381,7 +23371,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4name___get__(struct __pyx_o
* raise AttributeError("name cannot be altered")
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getname); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2640, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -23394,10 +23384,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4name___get__(struct __pyx_o
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2640, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2640, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -23405,7 +23395,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4name___get__(struct __pyx_o
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2629
+ /* "netCDF4/_netCDF4.pyx":2639
* property name:
* """string name of Group instance"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -23426,7 +23416,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_5Group_4name___get__(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2631
+/* "netCDF4/_netCDF4.pyx":2641
* def __get__(self):
* return self._getname()
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -23451,25 +23441,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group_4name_2__set__(CYTHON_UNUSED struc
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- /* "netCDF4/_netCDF4.pyx":2632
+ /* "netCDF4/_netCDF4.pyx":2642
* return self._getname()
* def __set__(self,value):
* raise AttributeError("name cannot be altered") # <<<<<<<<<<<<<<
*
*
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2642, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2642, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2631
+ /* "netCDF4/_netCDF4.pyx":2641
* def __get__(self):
* return self._getname()
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -23486,7 +23473,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_5Group_4name_2__set__(CYTHON_UNUSED struc
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2660
+/* "netCDF4/_netCDF4.pyx":2670
* `netCDF4.Variable` instance with `netCDF4.Dataset.createVariable`."""
*
* def __init__(self, grp, name, size=None, **kwargs): # <<<<<<<<<<<<<<
@@ -23505,9 +23492,6 @@ static int __pyx_pw_7netCDF4_8_netCDF4_9Dimension_1__init__(PyObject *__pyx_v_se
PyObject *__pyx_v_name = 0;
PyObject *__pyx_v_size = 0;
PyObject *__pyx_v_kwargs = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -23535,7 +23519,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_9Dimension_1__init__(PyObject *__pyx_v_se
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2660; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, 1); __PYX_ERR(0, 2670, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
@@ -23544,7 +23528,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_9Dimension_1__init__(PyObject *__pyx_v_se
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2660; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 2670, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -23561,7 +23545,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_9Dimension_1__init__(PyObject *__pyx_v_se
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2660; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2670, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("netCDF4._netCDF4.Dimension.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
@@ -23592,47 +23576,44 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
int __pyx_t_7;
char *__pyx_t_8;
size_t __pyx_t_9;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
- /* "netCDF4/_netCDF4.pyx":2679
+ /* "netCDF4/_netCDF4.pyx":2689
* cdef char *dimname
* cdef size_t lendim
* self._grpid = grp._grpid # <<<<<<<<<<<<<<
* # make a weakref to group to avoid circular ref (issue 218)
* # keep strong reference the default behaviour (issue 251)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2679; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2679; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2689, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_self->_grpid = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":2682
+ /* "netCDF4/_netCDF4.pyx":2692
* # make a weakref to group to avoid circular ref (issue 218)
* # keep strong reference the default behaviour (issue 251)
* if grp.keepweakref: # <<<<<<<<<<<<<<
* self._grp = weakref.proxy(grp)
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_keepweakref); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_keepweakref); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2692, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2692, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2683
+ /* "netCDF4/_netCDF4.pyx":2693
* # keep strong reference the default behaviour (issue 251)
* if grp.keepweakref:
* self._grp = weakref.proxy(grp) # <<<<<<<<<<<<<<
* else:
* self._grp = grp
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_weakref); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_weakref); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2693, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_proxy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_proxy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2693, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -23646,16 +23627,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
}
}
if (!__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_grp); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_grp); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2693, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2693, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_grp);
__Pyx_GIVEREF(__pyx_v_grp);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_grp);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2693, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -23666,7 +23647,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
__pyx_v_self->_grp = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2682
+ /* "netCDF4/_netCDF4.pyx":2692
* # make a weakref to group to avoid circular ref (issue 218)
* # keep strong reference the default behaviour (issue 251)
* if grp.keepweakref: # <<<<<<<<<<<<<<
@@ -23676,7 +23657,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":2685
+ /* "netCDF4/_netCDF4.pyx":2695
* self._grp = weakref.proxy(grp)
* else:
* self._grp = grp # <<<<<<<<<<<<<<
@@ -23692,14 +23673,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":2686
+ /* "netCDF4/_netCDF4.pyx":2696
* else:
* self._grp = grp
* self._data_model = grp.data_model # <<<<<<<<<<<<<<
* self._name = name
* if 'id' in kwargs:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2686; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2696, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_data_model);
@@ -23707,7 +23688,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
__pyx_v_self->_data_model = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2687
+ /* "netCDF4/_netCDF4.pyx":2697
* self._grp = grp
* self._data_model = grp.data_model
* self._name = name # <<<<<<<<<<<<<<
@@ -23720,31 +23701,31 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
__Pyx_DECREF(__pyx_v_self->_name);
__pyx_v_self->_name = __pyx_v_name;
- /* "netCDF4/_netCDF4.pyx":2688
+ /* "netCDF4/_netCDF4.pyx":2698
* self._data_model = grp.data_model
* self._name = name
* if 'id' in kwargs: # <<<<<<<<<<<<<<
* self._dimid = kwargs['id']
* else:
*/
- __pyx_t_3 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_id, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2688; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_id, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2698, __pyx_L1_error)
__pyx_t_7 = (__pyx_t_3 != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":2689
+ /* "netCDF4/_netCDF4.pyx":2699
* self._name = name
* if 'id' in kwargs:
* self._dimid = kwargs['id'] # <<<<<<<<<<<<<<
* else:
* bytestr = _strencode(name)
*/
- __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_id); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2689; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2699, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2689; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2699, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_self->_dimid = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":2688
+ /* "netCDF4/_netCDF4.pyx":2698
* self._data_model = grp.data_model
* self._name = name
* if 'id' in kwargs: # <<<<<<<<<<<<<<
@@ -23754,7 +23735,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
goto __pyx_L4;
}
- /* "netCDF4/_netCDF4.pyx":2691
+ /* "netCDF4/_netCDF4.pyx":2701
* self._dimid = kwargs['id']
* else:
* bytestr = _strencode(name) # <<<<<<<<<<<<<<
@@ -23762,22 +23743,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
* if size is not None:
*/
/*else*/ {
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2691; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2701, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":2692
+ /* "netCDF4/_netCDF4.pyx":2702
* else:
* bytestr = _strencode(name)
* dimname = bytestr # <<<<<<<<<<<<<<
* if size is not None:
* lendim = size
*/
- __pyx_t_8 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2692; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(0, 2702, __pyx_L1_error)
__pyx_v_dimname = __pyx_t_8;
- /* "netCDF4/_netCDF4.pyx":2693
+ /* "netCDF4/_netCDF4.pyx":2703
* bytestr = _strencode(name)
* dimname = bytestr
* if size is not None: # <<<<<<<<<<<<<<
@@ -23788,17 +23769,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
__pyx_t_3 = (__pyx_t_7 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2694
+ /* "netCDF4/_netCDF4.pyx":2704
* dimname = bytestr
* if size is not None:
* lendim = size # <<<<<<<<<<<<<<
* else:
* lendim = NC_UNLIMITED
*/
- __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_size); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_size); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 2704, __pyx_L1_error)
__pyx_v_lendim = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":2693
+ /* "netCDF4/_netCDF4.pyx":2703
* bytestr = _strencode(name)
* dimname = bytestr
* if size is not None: # <<<<<<<<<<<<<<
@@ -23808,7 +23789,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
goto __pyx_L5;
}
- /* "netCDF4/_netCDF4.pyx":2696
+ /* "netCDF4/_netCDF4.pyx":2706
* lendim = size
* else:
* lendim = NC_UNLIMITED # <<<<<<<<<<<<<<
@@ -23820,19 +23801,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
}
__pyx_L5:;
- /* "netCDF4/_netCDF4.pyx":2697
+ /* "netCDF4/_netCDF4.pyx":2707
* else:
* lendim = NC_UNLIMITED
* if grp.data_model != 'NETCDF4': grp._redef() # <<<<<<<<<<<<<<
* ierr = nc_def_dim(self._grpid, dimname, lendim, &self._dimid)
* if grp.data_model != 'NETCDF4': grp._enddef()
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2697; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2707, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2697; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2707, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2697; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2707, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -23845,17 +23826,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2697; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2707, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2697; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2707, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2698
+ /* "netCDF4/_netCDF4.pyx":2708
* lendim = NC_UNLIMITED
* if grp.data_model != 'NETCDF4': grp._redef()
* ierr = nc_def_dim(self._grpid, dimname, lendim, &self._dimid) # <<<<<<<<<<<<<<
@@ -23864,19 +23845,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
*/
__pyx_v_ierr = nc_def_dim(__pyx_v_self->_grpid, __pyx_v_dimname, __pyx_v_lendim, (&__pyx_v_self->_dimid));
- /* "netCDF4/_netCDF4.pyx":2699
+ /* "netCDF4/_netCDF4.pyx":2709
* if grp.data_model != 'NETCDF4': grp._redef()
* ierr = nc_def_dim(self._grpid, dimname, lendim, &self._dimid)
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2709, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2709, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2709, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -23889,17 +23870,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2709, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2709, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2700
+ /* "netCDF4/_netCDF4.pyx":2710
* ierr = nc_def_dim(self._grpid, dimname, lendim, &self._dimid)
* if grp.data_model != 'NETCDF4': grp._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -23909,7 +23890,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2701
+ /* "netCDF4/_netCDF4.pyx":2711
* if grp.data_model != 'NETCDF4': grp._enddef()
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -23917,22 +23898,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
* def _getname(self):
*/
__pyx_t_8 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_8, 0, strlen(__pyx_t_8), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2701; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_8, 0, strlen(__pyx_t_8), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2701; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2701; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2701; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2711, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2700
+ /* "netCDF4/_netCDF4.pyx":2710
* ierr = nc_def_dim(self._grpid, dimname, lendim, &self._dimid)
* if grp.data_model != 'NETCDF4': grp._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -23943,7 +23924,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
}
__pyx_L4:;
- /* "netCDF4/_netCDF4.pyx":2660
+ /* "netCDF4/_netCDF4.pyx":2670
* `netCDF4.Variable` instance with `netCDF4.Dataset.createVariable`."""
*
* def __init__(self, grp, name, size=None, **kwargs): # <<<<<<<<<<<<<<
@@ -23967,7 +23948,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension___init__(struct __pyx_obj_7net
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2703
+/* "netCDF4/_netCDF4.pyx":2713
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def _getname(self): # <<<<<<<<<<<<<<
@@ -24004,25 +23985,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
PyObject *__pyx_t_8 = NULL;
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_getname", 0);
- /* "netCDF4/_netCDF4.pyx":2707
+ /* "netCDF4/_netCDF4.pyx":2717
* cdef int err, _grpid
* cdef char namstring[NC_MAX_NAME+1]
* _grpid = self._grp._grpid # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_dimname(_grpid, self._dimid, namstring)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2717, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2717, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":2708
+ /* "netCDF4/_netCDF4.pyx":2718
* cdef char namstring[NC_MAX_NAME+1]
* _grpid = self._grp._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -24036,7 +24014,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":2709
+ /* "netCDF4/_netCDF4.pyx":2719
* _grpid = self._grp._grpid
* with nogil:
* ierr = nc_inq_dimname(_grpid, self._dimid, namstring) # <<<<<<<<<<<<<<
@@ -24046,7 +24024,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
__pyx_v_ierr = nc_inq_dimname(__pyx_v__grpid, __pyx_v_self->_dimid, __pyx_v_namstring);
}
- /* "netCDF4/_netCDF4.pyx":2708
+ /* "netCDF4/_netCDF4.pyx":2718
* cdef char namstring[NC_MAX_NAME+1]
* _grpid = self._grp._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -24064,7 +24042,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
}
}
- /* "netCDF4/_netCDF4.pyx":2710
+ /* "netCDF4/_netCDF4.pyx":2720
* with nogil:
* ierr = nc_inq_dimname(_grpid, self._dimid, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -24074,7 +24052,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":2711
+ /* "netCDF4/_netCDF4.pyx":2721
* ierr = nc_inq_dimname(_grpid, self._dimid, namstring)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -24082,22 +24060,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
*
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2721, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2721, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2721, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2721, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2710
+ /* "netCDF4/_netCDF4.pyx":2720
* with nogil:
* ierr = nc_inq_dimname(_grpid, self._dimid, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -24106,7 +24084,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
*/
}
- /* "netCDF4/_netCDF4.pyx":2712
+ /* "netCDF4/_netCDF4.pyx":2722
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* return namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
@@ -24114,14 +24092,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
* property name:
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2712; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2722, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2712; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2722, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2712; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2722, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2712; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2722, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -24135,7 +24113,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2712; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 2722, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -24146,7 +24124,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2712; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2722, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -24154,7 +24132,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2703
+ /* "netCDF4/_netCDF4.pyx":2713
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def _getname(self): # <<<<<<<<<<<<<<
@@ -24178,7 +24156,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_2_getname(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2716
+/* "netCDF4/_netCDF4.pyx":2726
* property name:
* """string name of Dimension instance"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -24205,12 +24183,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4name___get__(struct __p
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
- /* "netCDF4/_netCDF4.pyx":2717
+ /* "netCDF4/_netCDF4.pyx":2727
* """string name of Dimension instance"""
* def __get__(self):
* return self._getname() # <<<<<<<<<<<<<<
@@ -24218,7 +24193,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4name___get__(struct __p
* raise AttributeError("name cannot be altered")
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getname); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2717; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2727, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -24231,10 +24206,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4name___get__(struct __p
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2717; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2727, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2717; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2727, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -24242,7 +24217,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4name___get__(struct __p
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2716
+ /* "netCDF4/_netCDF4.pyx":2726
* property name:
* """string name of Dimension instance"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -24263,7 +24238,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4name___get__(struct __p
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2718
+/* "netCDF4/_netCDF4.pyx":2728
* def __get__(self):
* return self._getname()
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -24288,25 +24263,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension_4name_2__set__(CYTHON_UNUSED s
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- /* "netCDF4/_netCDF4.pyx":2719
+ /* "netCDF4/_netCDF4.pyx":2729
* return self._getname()
* def __set__(self,value):
* raise AttributeError("name cannot be altered") # <<<<<<<<<<<<<<
*
* property size:
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2729, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2729, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2718
+ /* "netCDF4/_netCDF4.pyx":2728
* def __get__(self):
* return self._getname()
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -24323,7 +24295,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension_4name_2__set__(CYTHON_UNUSED s
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2723
+/* "netCDF4/_netCDF4.pyx":2733
* property size:
* """current size of Dimension (calls `len` on Dimension instance)"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -24349,12 +24321,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4size___get__(struct __p
__Pyx_RefNannyDeclarations
Py_ssize_t __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
- /* "netCDF4/_netCDF4.pyx":2724
+ /* "netCDF4/_netCDF4.pyx":2734
* """current size of Dimension (calls `len` on Dimension instance)"""
* def __get__(self):
* return len(self) # <<<<<<<<<<<<<<
@@ -24362,14 +24331,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4size___get__(struct __p
* raise AttributeError("size cannot be altered")
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2724; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2724; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_Length(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 2734, __pyx_L1_error)
+ __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2734, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2723
+ /* "netCDF4/_netCDF4.pyx":2733
* property size:
* """current size of Dimension (calls `len` on Dimension instance)"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -24388,7 +24357,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4size___get__(struct __p
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2725
+/* "netCDF4/_netCDF4.pyx":2735
* def __get__(self):
* return len(self)
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -24413,25 +24382,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension_4size_2__set__(CYTHON_UNUSED s
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- /* "netCDF4/_netCDF4.pyx":2726
+ /* "netCDF4/_netCDF4.pyx":2736
* return len(self)
* def __set__(self,value):
* raise AttributeError("size cannot be altered") # <<<<<<<<<<<<<<
*
* def __repr__(self):
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2726; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2736, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2726; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2736, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2725
+ /* "netCDF4/_netCDF4.pyx":2735
* def __get__(self):
* return len(self)
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -24448,7 +24414,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension_4size_2__set__(CYTHON_UNUSED s
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2728
+/* "netCDF4/_netCDF4.pyx":2738
* raise AttributeError("size cannot be altered")
*
* def __repr__(self): # <<<<<<<<<<<<<<
@@ -24478,25 +24444,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
- /* "netCDF4/_netCDF4.pyx":2729
+ /* "netCDF4/_netCDF4.pyx":2739
*
* def __repr__(self):
* if python3: # <<<<<<<<<<<<<<
* return self.__unicode__()
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2739, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 2739, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":2730
+ /* "netCDF4/_netCDF4.pyx":2740
* def __repr__(self):
* if python3:
* return self.__unicode__() # <<<<<<<<<<<<<<
@@ -24504,7 +24467,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
* return unicode(self).encode(default_encoding)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2730; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2740, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -24517,10 +24480,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2730; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2740, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2730; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2740, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -24528,7 +24491,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2729
+ /* "netCDF4/_netCDF4.pyx":2739
*
* def __repr__(self):
* if python3: # <<<<<<<<<<<<<<
@@ -24537,7 +24500,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
*/
}
- /* "netCDF4/_netCDF4.pyx":2732
+ /* "netCDF4/_netCDF4.pyx":2742
* return self.__unicode__()
* else:
* return unicode(self).encode(default_encoding) # <<<<<<<<<<<<<<
@@ -24546,18 +24509,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2742, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2742, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2742, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2742, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -24570,17 +24533,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2742, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2742, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2742, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -24590,7 +24553,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":2728
+ /* "netCDF4/_netCDF4.pyx":2738
* raise AttributeError("size cannot be altered")
*
* def __repr__(self): # <<<<<<<<<<<<<<
@@ -24613,7 +24576,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_4__repr__(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2734
+/* "netCDF4/_netCDF4.pyx":2744
* return unicode(self).encode(default_encoding)
*
* def __unicode__(self): # <<<<<<<<<<<<<<
@@ -24643,12 +24606,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
Py_ssize_t __pyx_t_6;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__unicode__", 0);
- /* "netCDF4/_netCDF4.pyx":2735
+ /* "netCDF4/_netCDF4.pyx":2745
*
* def __unicode__(self):
* if not dir(self._grp): # <<<<<<<<<<<<<<
@@ -24657,15 +24617,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
*/
__pyx_t_1 = __pyx_v_self->_grp;
__Pyx_INCREF(__pyx_t_1);
- __pyx_t_2 = PyObject_Dir(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2735; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_Dir(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2745, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2735; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 2745, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = ((!__pyx_t_3) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":2736
+ /* "netCDF4/_netCDF4.pyx":2746
* def __unicode__(self):
* if not dir(self._grp):
* return 'Dimension object no longer valid' # <<<<<<<<<<<<<<
@@ -24677,7 +24637,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
__pyx_r = __pyx_kp_s_Dimension_object_no_longer_valid;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2735
+ /* "netCDF4/_netCDF4.pyx":2745
*
* def __unicode__(self):
* if not dir(self._grp): # <<<<<<<<<<<<<<
@@ -24686,14 +24646,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":2737
+ /* "netCDF4/_netCDF4.pyx":2747
* if not dir(self._grp):
* return 'Dimension object no longer valid'
* if self.isunlimited(): # <<<<<<<<<<<<<<
* return repr(type(self))+" (unlimited): name = '%s', size = %s\n" % (self._name,len(self))
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2737; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2747, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -24706,18 +24666,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
}
}
if (__pyx_t_5) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2737; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2747, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2737; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2747, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2737; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 2747, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":2738
+ /* "netCDF4/_netCDF4.pyx":2748
* return 'Dimension object no longer valid'
* if self.isunlimited():
* return repr(type(self))+" (unlimited): name = '%s', size = %s\n" % (self._name,len(self)) # <<<<<<<<<<<<<<
@@ -24725,12 +24685,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
* return repr(type(self))+": name = '%s', size = %s\n" % (self._name,len(self))
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_6 = PyObject_Length(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_Length(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 2748, __pyx_L1_error)
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_self->_name);
__Pyx_GIVEREF(__pyx_v_self->_name);
@@ -24738,10 +24698,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_unlimited_name_s_size_s, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_unlimited_name_s_size_s, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyNumber_Add(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -24749,7 +24709,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
__pyx_t_5 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2737
+ /* "netCDF4/_netCDF4.pyx":2747
* if not dir(self._grp):
* return 'Dimension object no longer valid'
* if self.isunlimited(): # <<<<<<<<<<<<<<
@@ -24758,7 +24718,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":2740
+ /* "netCDF4/_netCDF4.pyx":2750
* return repr(type(self))+" (unlimited): name = '%s', size = %s\n" % (self._name,len(self))
* else:
* return repr(type(self))+": name = '%s', size = %s\n" % (self._name,len(self)) # <<<<<<<<<<<<<<
@@ -24767,12 +24727,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_5 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PyObject_Length(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_Length(((PyObject *)__pyx_v_self)); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 2750, __pyx_L1_error)
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_self->_name);
__Pyx_GIVEREF(__pyx_v_self->_name);
@@ -24780,10 +24740,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_name_s_size_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_name_s_size_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Add(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Add(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -24792,7 +24752,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":2734
+ /* "netCDF4/_netCDF4.pyx":2744
* return unicode(self).encode(default_encoding)
*
* def __unicode__(self): # <<<<<<<<<<<<<<
@@ -24813,7 +24773,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6__unicode__(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2742
+/* "netCDF4/_netCDF4.pyx":2752
* return repr(type(self))+": name = '%s', size = %s\n" % (self._name,len(self))
*
* def __len__(self): # <<<<<<<<<<<<<<
@@ -24843,12 +24803,9 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
char *__pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__len__", 0);
- /* "netCDF4/_netCDF4.pyx":2746
+ /* "netCDF4/_netCDF4.pyx":2756
* cdef int ierr
* cdef size_t lengthp
* with nogil: # <<<<<<<<<<<<<<
@@ -24862,7 +24819,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":2747
+ /* "netCDF4/_netCDF4.pyx":2757
* cdef size_t lengthp
* with nogil:
* ierr = nc_inq_dimlen(self._grpid, self._dimid, &lengthp) # <<<<<<<<<<<<<<
@@ -24872,7 +24829,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
__pyx_v_ierr = nc_inq_dimlen(__pyx_v_self->_grpid, __pyx_v_self->_dimid, (&__pyx_v_lengthp));
}
- /* "netCDF4/_netCDF4.pyx":2746
+ /* "netCDF4/_netCDF4.pyx":2756
* cdef int ierr
* cdef size_t lengthp
* with nogil: # <<<<<<<<<<<<<<
@@ -24890,7 +24847,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
}
}
- /* "netCDF4/_netCDF4.pyx":2748
+ /* "netCDF4/_netCDF4.pyx":2758
* with nogil:
* ierr = nc_inq_dimlen(self._grpid, self._dimid, &lengthp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -24900,7 +24857,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2749
+ /* "netCDF4/_netCDF4.pyx":2759
* ierr = nc_inq_dimlen(self._grpid, self._dimid, &lengthp)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -24908,22 +24865,22 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
*
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2749; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2759, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2749; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2759, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2749; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2759, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2749; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2759, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2748
+ /* "netCDF4/_netCDF4.pyx":2758
* with nogil:
* ierr = nc_inq_dimlen(self._grpid, self._dimid, &lengthp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -24932,7 +24889,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
*/
}
- /* "netCDF4/_netCDF4.pyx":2750
+ /* "netCDF4/_netCDF4.pyx":2760
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* return lengthp # <<<<<<<<<<<<<<
@@ -24942,7 +24899,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
__pyx_r = __pyx_v_lengthp;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2742
+ /* "netCDF4/_netCDF4.pyx":2752
* return repr(type(self))+": name = '%s', size = %s\n" % (self._name,len(self))
*
* def __len__(self): # <<<<<<<<<<<<<<
@@ -24961,7 +24918,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_9Dimension_8__len__(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2752
+/* "netCDF4/_netCDF4.pyx":2762
* return lengthp
*
* def group(self): # <<<<<<<<<<<<<<
@@ -24988,7 +24945,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_10group(struct __pyx_obj
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("group", 0);
- /* "netCDF4/_netCDF4.pyx":2757
+ /* "netCDF4/_netCDF4.pyx":2767
*
* return the group that this `netCDF4.Dimension` is a member of."""
* return self._grp # <<<<<<<<<<<<<<
@@ -25000,7 +24957,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_10group(struct __pyx_obj
__pyx_r = __pyx_v_self->_grp;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2752
+ /* "netCDF4/_netCDF4.pyx":2762
* return lengthp
*
* def group(self): # <<<<<<<<<<<<<<
@@ -25015,7 +24972,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_10group(struct __pyx_obj
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2759
+/* "netCDF4/_netCDF4.pyx":2769
* return self._grp
*
* def isunlimited(self): # <<<<<<<<<<<<<<
@@ -25057,22 +25014,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
int __pyx_t_5;
int __pyx_t_6;
int __pyx_t_7;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("isunlimited", 0);
- /* "netCDF4/_netCDF4.pyx":2766
+ /* "netCDF4/_netCDF4.pyx":2776
* cdef int ierr, n, numunlimdims, ndims, nvars, ngatts, xdimid
* cdef int *unlimdimids
* if self._data_model == 'NETCDF4': # <<<<<<<<<<<<<<
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, NULL)
* if ierr != NC_NOERR:
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->_data_model, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2766; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_self->_data_model, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2776, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2767
+ /* "netCDF4/_netCDF4.pyx":2777
* cdef int *unlimdimids
* if self._data_model == 'NETCDF4':
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, NULL) # <<<<<<<<<<<<<<
@@ -25081,7 +25035,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
*/
__pyx_v_ierr = nc_inq_unlimdims(__pyx_v_self->_grpid, (&__pyx_v_numunlimdims), NULL);
- /* "netCDF4/_netCDF4.pyx":2768
+ /* "netCDF4/_netCDF4.pyx":2778
* if self._data_model == 'NETCDF4':
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -25091,7 +25045,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2769
+ /* "netCDF4/_netCDF4.pyx":2779
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, NULL)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -25099,22 +25053,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
* return False
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2779, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2779, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2779, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2779, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2768
+ /* "netCDF4/_netCDF4.pyx":2778
* if self._data_model == 'NETCDF4':
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -25123,7 +25077,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":2770
+ /* "netCDF4/_netCDF4.pyx":2780
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if numunlimdims == 0: # <<<<<<<<<<<<<<
@@ -25133,7 +25087,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_t_1 = ((__pyx_v_numunlimdims == 0) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2771
+ /* "netCDF4/_netCDF4.pyx":2781
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if numunlimdims == 0:
* return False # <<<<<<<<<<<<<<
@@ -25145,7 +25099,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_r = Py_False;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2770
+ /* "netCDF4/_netCDF4.pyx":2780
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if numunlimdims == 0: # <<<<<<<<<<<<<<
@@ -25154,7 +25108,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":2773
+ /* "netCDF4/_netCDF4.pyx":2783
* return False
* else:
* unlimdimids = <int *>malloc(sizeof(int) * numunlimdims) # <<<<<<<<<<<<<<
@@ -25164,7 +25118,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
/*else*/ {
__pyx_v_unlimdimids = ((int *)malloc(((sizeof(int)) * __pyx_v_numunlimdims)));
- /* "netCDF4/_netCDF4.pyx":2774
+ /* "netCDF4/_netCDF4.pyx":2784
* else:
* unlimdimids = <int *>malloc(sizeof(int) * numunlimdims)
* dimid = self._dimid # <<<<<<<<<<<<<<
@@ -25174,7 +25128,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_t_5 = __pyx_v_self->_dimid;
__pyx_v_dimid = __pyx_t_5;
- /* "netCDF4/_netCDF4.pyx":2775
+ /* "netCDF4/_netCDF4.pyx":2785
* unlimdimids = <int *>malloc(sizeof(int) * numunlimdims)
* dimid = self._dimid
* with nogil: # <<<<<<<<<<<<<<
@@ -25188,7 +25142,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":2776
+ /* "netCDF4/_netCDF4.pyx":2786
* dimid = self._dimid
* with nogil:
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, unlimdimids) # <<<<<<<<<<<<<<
@@ -25198,7 +25152,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_v_ierr = nc_inq_unlimdims(__pyx_v_self->_grpid, (&__pyx_v_numunlimdims), __pyx_v_unlimdimids);
}
- /* "netCDF4/_netCDF4.pyx":2775
+ /* "netCDF4/_netCDF4.pyx":2785
* unlimdimids = <int *>malloc(sizeof(int) * numunlimdims)
* dimid = self._dimid
* with nogil: # <<<<<<<<<<<<<<
@@ -25216,7 +25170,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
}
}
- /* "netCDF4/_netCDF4.pyx":2777
+ /* "netCDF4/_netCDF4.pyx":2787
* with nogil:
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, unlimdimids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -25226,7 +25180,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":2778
+ /* "netCDF4/_netCDF4.pyx":2788
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, unlimdimids)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -25234,22 +25188,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
* for n from 0 <= n < numunlimdims:
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2788, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2788, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2788, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 2788, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":2777
+ /* "netCDF4/_netCDF4.pyx":2787
* with nogil:
* ierr = nc_inq_unlimdims(self._grpid, &numunlimdims, unlimdimids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -25258,19 +25212,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":2779
+ /* "netCDF4/_netCDF4.pyx":2789
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* unlimdim_ids = [] # <<<<<<<<<<<<<<
* for n from 0 <= n < numunlimdims:
* unlimdim_ids.append(unlimdimids[n])
*/
- __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2779; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_unlimdim_ids = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2780
+ /* "netCDF4/_netCDF4.pyx":2790
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* unlimdim_ids = []
* for n from 0 <= n < numunlimdims: # <<<<<<<<<<<<<<
@@ -25280,20 +25234,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_t_5 = __pyx_v_numunlimdims;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_5; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":2781
+ /* "netCDF4/_netCDF4.pyx":2791
* unlimdim_ids = []
* for n from 0 <= n < numunlimdims:
* unlimdim_ids.append(unlimdimids[n]) # <<<<<<<<<<<<<<
* free(unlimdimids)
* if dimid in unlimdim_ids:
*/
- __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_unlimdimids[__pyx_v_n])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2781; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_unlimdimids[__pyx_v_n])); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2791, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_unlimdim_ids, __pyx_t_3); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2781; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyList_Append(__pyx_v_unlimdim_ids, __pyx_t_3); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 2791, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":2782
+ /* "netCDF4/_netCDF4.pyx":2792
* for n from 0 <= n < numunlimdims:
* unlimdim_ids.append(unlimdimids[n])
* free(unlimdimids) # <<<<<<<<<<<<<<
@@ -25302,21 +25256,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
*/
free(__pyx_v_unlimdimids);
- /* "netCDF4/_netCDF4.pyx":2783
+ /* "netCDF4/_netCDF4.pyx":2793
* unlimdim_ids.append(unlimdimids[n])
* free(unlimdimids)
* if dimid in unlimdim_ids: # <<<<<<<<<<<<<<
* return True
* else:
*/
- __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dimid); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2783; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dimid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2793, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_v_unlimdim_ids, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2783; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_v_unlimdim_ids, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 2793, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_7 = (__pyx_t_1 != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":2784
+ /* "netCDF4/_netCDF4.pyx":2794
* free(unlimdimids)
* if dimid in unlimdim_ids:
* return True # <<<<<<<<<<<<<<
@@ -25328,7 +25282,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_r = Py_True;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2783
+ /* "netCDF4/_netCDF4.pyx":2793
* unlimdim_ids.append(unlimdimids[n])
* free(unlimdimids)
* if dimid in unlimdim_ids: # <<<<<<<<<<<<<<
@@ -25337,7 +25291,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":2786
+ /* "netCDF4/_netCDF4.pyx":2796
* return True
* else:
* return False # <<<<<<<<<<<<<<
@@ -25352,7 +25306,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
}
}
- /* "netCDF4/_netCDF4.pyx":2766
+ /* "netCDF4/_netCDF4.pyx":2776
* cdef int ierr, n, numunlimdims, ndims, nvars, ngatts, xdimid
* cdef int *unlimdimids
* if self._data_model == 'NETCDF4': # <<<<<<<<<<<<<<
@@ -25361,7 +25315,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":2789
+ /* "netCDF4/_netCDF4.pyx":2799
* else: # if not NETCDF4, there is only one unlimited dimension.
* # nc_inq_unlimdims only works for NETCDF4.
* with nogil: # <<<<<<<<<<<<<<
@@ -25376,7 +25330,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":2790
+ /* "netCDF4/_netCDF4.pyx":2800
* # nc_inq_unlimdims only works for NETCDF4.
* with nogil:
* ierr = nc_inq(self._grpid, &ndims, &nvars, &ngatts, &xdimid) # <<<<<<<<<<<<<<
@@ -25386,7 +25340,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_v_ierr = nc_inq(__pyx_v_self->_grpid, (&__pyx_v_ndims), (&__pyx_v_nvars), (&__pyx_v_ngatts), (&__pyx_v_xdimid));
}
- /* "netCDF4/_netCDF4.pyx":2789
+ /* "netCDF4/_netCDF4.pyx":2799
* else: # if not NETCDF4, there is only one unlimited dimension.
* # nc_inq_unlimdims only works for NETCDF4.
* with nogil: # <<<<<<<<<<<<<<
@@ -25404,7 +25358,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
}
}
- /* "netCDF4/_netCDF4.pyx":2791
+ /* "netCDF4/_netCDF4.pyx":2801
* with nogil:
* ierr = nc_inq(self._grpid, &ndims, &nvars, &ngatts, &xdimid)
* if self._dimid == xdimid: # <<<<<<<<<<<<<<
@@ -25414,7 +25368,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_t_7 = ((__pyx_v_self->_dimid == __pyx_v_xdimid) != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":2792
+ /* "netCDF4/_netCDF4.pyx":2802
* ierr = nc_inq(self._grpid, &ndims, &nvars, &ngatts, &xdimid)
* if self._dimid == xdimid:
* return True # <<<<<<<<<<<<<<
@@ -25426,7 +25380,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
__pyx_r = Py_True;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":2791
+ /* "netCDF4/_netCDF4.pyx":2801
* with nogil:
* ierr = nc_inq(self._grpid, &ndims, &nvars, &ngatts, &xdimid)
* if self._dimid == xdimid: # <<<<<<<<<<<<<<
@@ -25435,7 +25389,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":2794
+ /* "netCDF4/_netCDF4.pyx":2804
* return True
* else:
* return False # <<<<<<<<<<<<<<
@@ -25450,7 +25404,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
}
}
- /* "netCDF4/_netCDF4.pyx":2759
+ /* "netCDF4/_netCDF4.pyx":2769
* return self._grp
*
* def isunlimited(self): # <<<<<<<<<<<<<<
@@ -25471,7 +25425,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_12isunlimited(struct __p
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2653
+/* "netCDF4/_netCDF4.pyx":2663
* `netCDF4.Dimension` instance).
* """
* cdef public int _dimid, _grpid # <<<<<<<<<<<<<<
@@ -25496,12 +25450,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6_dimid___get__(struct _
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_dimid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_dimid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2663, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -25535,11 +25486,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension_6_dimid_2__set__(struct __pyx_
int __pyx_r;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2663, __pyx_L1_error)
__pyx_v_self->_dimid = __pyx_t_1;
/* function exit code */
@@ -25570,12 +25518,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9Dimension_6_grpid___get__(struct _
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2663, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -25609,11 +25554,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension_6_grpid_2__set__(struct __pyx_
int __pyx_r;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2663, __pyx_L1_error)
__pyx_v_self->_grpid = __pyx_t_1;
/* function exit code */
@@ -25627,7 +25569,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension_6_grpid_2__set__(struct __pyx_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2654
+/* "netCDF4/_netCDF4.pyx":2664
* """
* cdef public int _dimid, _grpid
* cdef public _data_model, _name, _grp # <<<<<<<<<<<<<<
@@ -25896,7 +25838,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_9Dimension_4_grp_4__del__(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2890
+/* "netCDF4/_netCDF4.pyx":2900
* """The number of stored elements."""
*
* def __init__(self, grp, name, datatype, dimensions=(), zlib=False, # <<<<<<<<<<<<<<
@@ -25926,9 +25868,6 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8Variable_1__init__(PyObject *__pyx_v_sel
PyObject *__pyx_v_fill_value = 0;
PyObject *__pyx_v_chunk_cache = 0;
PyObject *__pyx_v_kwargs = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -25941,7 +25880,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8Variable_1__init__(PyObject *__pyx_v_sel
values[4] = ((PyObject *)Py_False);
values[5] = ((PyObject *)__pyx_int_4);
- /* "netCDF4/_netCDF4.pyx":2891
+ /* "netCDF4/_netCDF4.pyx":2901
*
* def __init__(self, grp, name, datatype, dimensions=(), zlib=False,
* complevel=4, shuffle=True, fletcher32=False, contiguous=False, # <<<<<<<<<<<<<<
@@ -25952,7 +25891,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8Variable_1__init__(PyObject *__pyx_v_sel
values[7] = ((PyObject *)Py_False);
values[8] = ((PyObject *)Py_False);
- /* "netCDF4/_netCDF4.pyx":2892
+ /* "netCDF4/_netCDF4.pyx":2902
* def __init__(self, grp, name, datatype, dimensions=(), zlib=False,
* complevel=4, shuffle=True, fletcher32=False, contiguous=False,
* chunksizes=None, endian='native', least_significant_digit=None, # <<<<<<<<<<<<<<
@@ -25963,7 +25902,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8Variable_1__init__(PyObject *__pyx_v_sel
values[10] = ((PyObject *)__pyx_n_s_native);
values[11] = ((PyObject *)Py_None);
- /* "netCDF4/_netCDF4.pyx":2893
+ /* "netCDF4/_netCDF4.pyx":2903
* complevel=4, shuffle=True, fletcher32=False, contiguous=False,
* chunksizes=None, endian='native', least_significant_digit=None,
* fill_value=None, chunk_cache=None, **kwargs): # <<<<<<<<<<<<<<
@@ -26001,12 +25940,12 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8Variable_1__init__(PyObject *__pyx_v_sel
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 14, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2890; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 14, 1); __PYX_ERR(0, 2900, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_datatype)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 14, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2890; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 14, 2); __PYX_ERR(0, 2900, __pyx_L3_error)
}
case 3:
if (kw_args > 0) {
@@ -26065,7 +26004,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8Variable_1__init__(PyObject *__pyx_v_sel
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2890; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 2900, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -26104,7 +26043,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8Variable_1__init__(PyObject *__pyx_v_sel
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 14, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2890; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 3, 14, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2900, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("netCDF4._netCDF4.Variable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
@@ -26113,7 +26052,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8Variable_1__init__(PyObject *__pyx_v_sel
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(((struct __pyx_obj_7netCDF4_8_netCDF4_Variable *)__pyx_v_self), __pyx_v_grp, __pyx_v_name, __pyx_v_datatype, __pyx_v_dimensions, __pyx_v_zlib, __pyx_v_complevel, __pyx_v_shuffle, __pyx_v_fletcher32, __pyx_v_contiguous, __pyx_v_chunksizes, __pyx_v_endian, __pyx_v_least_significant_digit, __pyx_v_fill_value, __pyx_v_chunk_cache, __pyx_v_kwargs);
- /* "netCDF4/_netCDF4.pyx":2890
+ /* "netCDF4/_netCDF4.pyx":2900
* """The number of stored elements."""
*
* def __init__(self, grp, name, datatype, dimensions=(), zlib=False, # <<<<<<<<<<<<<<
@@ -26169,15 +26108,12 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
struct __pyx_opt_args_7netCDF4_8_netCDF4__set_att __pyx_t_16;
PyObject *(*__pyx_t_17)(PyObject *);
PyObject *__pyx_t_18 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
__Pyx_INCREF(__pyx_v_datatype);
__Pyx_INCREF(__pyx_v_dimensions);
__Pyx_INCREF(__pyx_v_zlib);
- /* "netCDF4/_netCDF4.pyx":2992
+ /* "netCDF4/_netCDF4.pyx":3002
* cdef float preemptionp
* # flag to indicate that orthogonal indexing is supported
* self.__orthogonal_indexing__ = True # <<<<<<<<<<<<<<
@@ -26190,18 +26126,18 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->__orthogonal_indexing__);
__pyx_v_self->__orthogonal_indexing__ = Py_True;
- /* "netCDF4/_netCDF4.pyx":2994
+ /* "netCDF4/_netCDF4.pyx":3004
* self.__orthogonal_indexing__ = True
* # if complevel is set to zero, set zlib to False.
* if not complevel: # <<<<<<<<<<<<<<
* zlib = False
* # if dimensions is a string, convert to a tuple
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_complevel); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2994; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_complevel); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3004, __pyx_L1_error)
__pyx_t_2 = ((!__pyx_t_1) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":2995
+ /* "netCDF4/_netCDF4.pyx":3005
* # if complevel is set to zero, set zlib to False.
* if not complevel:
* zlib = False # <<<<<<<<<<<<<<
@@ -26211,7 +26147,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(Py_False);
__Pyx_DECREF_SET(__pyx_v_zlib, Py_False);
- /* "netCDF4/_netCDF4.pyx":2994
+ /* "netCDF4/_netCDF4.pyx":3004
* self.__orthogonal_indexing__ = True
* # if complevel is set to zero, set zlib to False.
* if not complevel: # <<<<<<<<<<<<<<
@@ -26220,44 +26156,44 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":2999
+ /* "netCDF4/_netCDF4.pyx":3009
* # this prevents a common error that occurs when
* # dimensions = 'lat' instead of ('lat',)
* if type(dimensions) == str or type(dimensions) == bytes or type(dimensions) == unicode: # <<<<<<<<<<<<<<
* dimensions = dimensions,
* self._grpid = grp._grpid
*/
- __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dimensions)), ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dimensions)), ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3009, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3009, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (!__pyx_t_1) {
} else {
__pyx_t_2 = __pyx_t_1;
goto __pyx_L5_bool_binop_done;
}
- __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dimensions)), ((PyObject *)(&PyBytes_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dimensions)), ((PyObject *)(&PyBytes_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3009, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3009, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (!__pyx_t_1) {
} else {
__pyx_t_2 = __pyx_t_1;
goto __pyx_L5_bool_binop_done;
}
- __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dimensions)), ((PyObject *)(&PyUnicode_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_dimensions)), ((PyObject *)(&PyUnicode_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3009, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3009, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __pyx_t_1;
__pyx_L5_bool_binop_done:;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3000
+ /* "netCDF4/_netCDF4.pyx":3010
* # dimensions = 'lat' instead of ('lat',)
* if type(dimensions) == str or type(dimensions) == bytes or type(dimensions) == unicode:
* dimensions = dimensions, # <<<<<<<<<<<<<<
* self._grpid = grp._grpid
* # make a weakref to group to avoid circular ref (issue 218)
*/
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3000; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3010, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_dimensions);
__Pyx_GIVEREF(__pyx_v_dimensions);
@@ -26265,7 +26201,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF_SET(__pyx_v_dimensions, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":2999
+ /* "netCDF4/_netCDF4.pyx":3009
* # this prevents a common error that occurs when
* # dimensions = 'lat' instead of ('lat',)
* if type(dimensions) == str or type(dimensions) == bytes or type(dimensions) == unicode: # <<<<<<<<<<<<<<
@@ -26274,42 +26210,42 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3001
+ /* "netCDF4/_netCDF4.pyx":3011
* if type(dimensions) == str or type(dimensions) == bytes or type(dimensions) == unicode:
* dimensions = dimensions,
* self._grpid = grp._grpid # <<<<<<<<<<<<<<
* # make a weakref to group to avoid circular ref (issue 218)
* # keep strong reference the default behaviour (issue 251)
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3001; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3011, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3001; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3011, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_self->_grpid = __pyx_t_4;
- /* "netCDF4/_netCDF4.pyx":3004
+ /* "netCDF4/_netCDF4.pyx":3014
* # make a weakref to group to avoid circular ref (issue 218)
* # keep strong reference the default behaviour (issue 251)
* if grp.keepweakref: # <<<<<<<<<<<<<<
* self._grp = weakref.proxy(grp)
* else:
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_keepweakref); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_keepweakref); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3014, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3014, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3005
+ /* "netCDF4/_netCDF4.pyx":3015
* # keep strong reference the default behaviour (issue 251)
* if grp.keepweakref:
* self._grp = weakref.proxy(grp) # <<<<<<<<<<<<<<
* else:
* self._grp = grp
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_weakref); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3005; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_weakref); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3015, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_proxy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3005; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_proxy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3015, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = NULL;
@@ -26323,16 +26259,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (!__pyx_t_5) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_grp); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3005; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_grp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3015, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3005; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3015, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_grp);
__Pyx_GIVEREF(__pyx_v_grp);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_grp);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3005; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3015, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -26343,7 +26279,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_v_self->_grp = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3004
+ /* "netCDF4/_netCDF4.pyx":3014
* # make a weakref to group to avoid circular ref (issue 218)
* # keep strong reference the default behaviour (issue 251)
* if grp.keepweakref: # <<<<<<<<<<<<<<
@@ -26353,7 +26289,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L8;
}
- /* "netCDF4/_netCDF4.pyx":3007
+ /* "netCDF4/_netCDF4.pyx":3017
* self._grp = weakref.proxy(grp)
* else:
* self._grp = grp # <<<<<<<<<<<<<<
@@ -26369,7 +26305,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L8:;
- /* "netCDF4/_netCDF4.pyx":3008
+ /* "netCDF4/_netCDF4.pyx":3018
* else:
* self._grp = grp
* user_type = isinstance(datatype, CompoundType) or \ # <<<<<<<<<<<<<<
@@ -26379,14 +26315,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = __Pyx_TypeCheck(__pyx_v_datatype, __pyx_ptype_7netCDF4_8_netCDF4_CompoundType);
if (!__pyx_t_2) {
} else {
- __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3018, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = __pyx_t_6;
__pyx_t_6 = 0;
goto __pyx_L9_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":3009
+ /* "netCDF4/_netCDF4.pyx":3019
* self._grp = grp
* user_type = isinstance(datatype, CompoundType) or \
* isinstance(datatype, VLType) or \ # <<<<<<<<<<<<<<
@@ -26396,14 +26332,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = __Pyx_TypeCheck(__pyx_v_datatype, __pyx_ptype_7netCDF4_8_netCDF4_VLType);
if (!__pyx_t_2) {
} else {
- __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3009; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3019, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = __pyx_t_6;
__pyx_t_6 = 0;
goto __pyx_L9_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":3010
+ /* "netCDF4/_netCDF4.pyx":3020
* user_type = isinstance(datatype, CompoundType) or \
* isinstance(datatype, VLType) or \
* isinstance(datatype, EnumType) or \ # <<<<<<<<<<<<<<
@@ -26413,21 +26349,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = __Pyx_TypeCheck(__pyx_v_datatype, __pyx_ptype_7netCDF4_8_netCDF4_EnumType);
if (!__pyx_t_2) {
} else {
- __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3010; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3020, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = __pyx_t_6;
__pyx_t_6 = 0;
goto __pyx_L9_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":3011
+ /* "netCDF4/_netCDF4.pyx":3021
* isinstance(datatype, VLType) or \
* isinstance(datatype, EnumType) or \
* datatype == str # <<<<<<<<<<<<<<
* # convert to a real numpy datatype object if necessary.
* if not user_type and type(datatype) != numpy.dtype:
*/
- __pyx_t_6 = PyObject_RichCompare(__pyx_v_datatype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_RichCompare(__pyx_v_datatype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3021, __pyx_L1_error)
__Pyx_INCREF(__pyx_t_6);
__pyx_t_3 = __pyx_t_6;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -26435,43 +26371,43 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_v_user_type = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3013
+ /* "netCDF4/_netCDF4.pyx":3023
* datatype == str
* # convert to a real numpy datatype object if necessary.
* if not user_type and type(datatype) != numpy.dtype: # <<<<<<<<<<<<<<
* datatype = numpy.dtype(datatype)
* # convert numpy string dtype with length > 1
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_user_type); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3013; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_user_type); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3023, __pyx_L1_error)
__pyx_t_8 = ((!__pyx_t_1) != 0);
if (__pyx_t_8) {
} else {
__pyx_t_2 = __pyx_t_8;
goto __pyx_L14_bool_binop_done;
}
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3013; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3013; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_datatype)), __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3013; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_datatype)), __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3023, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3013; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3023, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __pyx_t_8;
__pyx_L14_bool_binop_done:;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3014
+ /* "netCDF4/_netCDF4.pyx":3024
* # convert to a real numpy datatype object if necessary.
* if not user_type and type(datatype) != numpy.dtype:
* datatype = numpy.dtype(datatype) # <<<<<<<<<<<<<<
* # convert numpy string dtype with length > 1
* # or any numpy unicode dtype into str
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3024, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3024, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -26485,16 +26421,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (!__pyx_t_6) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_datatype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_datatype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3024, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3024, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_datatype);
__Pyx_GIVEREF(__pyx_v_datatype);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_datatype);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3024, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
@@ -26502,7 +26438,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF_SET(__pyx_v_datatype, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3013
+ /* "netCDF4/_netCDF4.pyx":3023
* datatype == str
* # convert to a real numpy datatype object if necessary.
* if not user_type and type(datatype) != numpy.dtype: # <<<<<<<<<<<<<<
@@ -26511,19 +26447,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3017
+ /* "netCDF4/_netCDF4.pyx":3027
* # convert numpy string dtype with length > 1
* # or any numpy unicode dtype into str
* if (isinstance(datatype, numpy.dtype) and # <<<<<<<<<<<<<<
* ((datatype.kind == 'S' and datatype.itemsize > 1) or
* datatype.kind == 'U')):
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3017; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3027, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3017; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3027, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_8 = PyObject_IsInstance(__pyx_v_datatype, __pyx_t_7); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3017; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_IsInstance(__pyx_v_datatype, __pyx_t_7); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 3027, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_1 = (__pyx_t_8 != 0);
if (__pyx_t_1) {
@@ -26532,26 +26468,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L17_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":3018
+ /* "netCDF4/_netCDF4.pyx":3028
* # or any numpy unicode dtype into str
* if (isinstance(datatype, numpy.dtype) and
* ((datatype.kind == 'S' and datatype.itemsize > 1) or # <<<<<<<<<<<<<<
* datatype.kind == 'U')):
* datatype = str
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_kind); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_kind); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3028, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_S, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_S, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3028, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (!__pyx_t_1) {
goto __pyx_L19_next_or;
} else {
}
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3028, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_3 = PyObject_RichCompare(__pyx_t_7, __pyx_int_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_7, __pyx_int_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3028, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3028, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (!__pyx_t_1) {
} else {
@@ -26560,21 +26496,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L19_next_or:;
- /* "netCDF4/_netCDF4.pyx":3019
+ /* "netCDF4/_netCDF4.pyx":3029
* if (isinstance(datatype, numpy.dtype) and
* ((datatype.kind == 'S' and datatype.itemsize > 1) or
* datatype.kind == 'U')): # <<<<<<<<<<<<<<
* datatype = str
* user_type = True
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_kind); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3019; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_kind); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3029, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_U, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3019; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_U, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3029, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __pyx_t_1;
__pyx_L17_bool_binop_done:;
- /* "netCDF4/_netCDF4.pyx":3017
+ /* "netCDF4/_netCDF4.pyx":3027
* # convert numpy string dtype with length > 1
* # or any numpy unicode dtype into str
* if (isinstance(datatype, numpy.dtype) and # <<<<<<<<<<<<<<
@@ -26583,7 +26519,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3020
+ /* "netCDF4/_netCDF4.pyx":3030
* ((datatype.kind == 'S' and datatype.itemsize > 1) or
* datatype.kind == 'U')):
* datatype = str # <<<<<<<<<<<<<<
@@ -26593,7 +26529,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(((PyObject *)(&PyString_Type)));
__Pyx_DECREF_SET(__pyx_v_datatype, ((PyObject *)(&PyString_Type)));
- /* "netCDF4/_netCDF4.pyx":3021
+ /* "netCDF4/_netCDF4.pyx":3031
* datatype.kind == 'U')):
* datatype = str
* user_type = True # <<<<<<<<<<<<<<
@@ -26603,7 +26539,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(Py_True);
__Pyx_DECREF_SET(__pyx_v_user_type, Py_True);
- /* "netCDF4/_netCDF4.pyx":3017
+ /* "netCDF4/_netCDF4.pyx":3027
* # convert numpy string dtype with length > 1
* # or any numpy unicode dtype into str
* if (isinstance(datatype, numpy.dtype) and # <<<<<<<<<<<<<<
@@ -26612,71 +26548,71 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3023
+ /* "netCDF4/_netCDF4.pyx":3033
* user_type = True
* # check if endian keyword consistent with datatype specification.
* dtype_endian = getattr(datatype,'byteorder',None) # <<<<<<<<<<<<<<
* if dtype_endian == '=': dtype_endian='native'
* if dtype_endian == '>': dtype_endian='big'
*/
- __pyx_t_3 = __Pyx_GetAttr3(__pyx_v_datatype, __pyx_n_s_byteorder, Py_None); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetAttr3(__pyx_v_datatype, __pyx_n_s_byteorder, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3033, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_dtype_endian = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3024
+ /* "netCDF4/_netCDF4.pyx":3034
* # check if endian keyword consistent with datatype specification.
* dtype_endian = getattr(datatype,'byteorder',None)
* if dtype_endian == '=': dtype_endian='native' # <<<<<<<<<<<<<<
* if dtype_endian == '>': dtype_endian='big'
* if dtype_endian == '<': dtype_endian='little'
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_kp_s__36, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3024; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_kp_s__36, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3034, __pyx_L1_error)
if (__pyx_t_2) {
__Pyx_INCREF(__pyx_n_s_native);
__Pyx_DECREF_SET(__pyx_v_dtype_endian, __pyx_n_s_native);
}
- /* "netCDF4/_netCDF4.pyx":3025
+ /* "netCDF4/_netCDF4.pyx":3035
* dtype_endian = getattr(datatype,'byteorder',None)
* if dtype_endian == '=': dtype_endian='native'
* if dtype_endian == '>': dtype_endian='big' # <<<<<<<<<<<<<<
* if dtype_endian == '<': dtype_endian='little'
* if dtype_endian == '|': dtype_endian=None
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_kp_s__15, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_kp_s__15, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3035, __pyx_L1_error)
if (__pyx_t_2) {
__Pyx_INCREF(__pyx_n_s_big);
__Pyx_DECREF_SET(__pyx_v_dtype_endian, __pyx_n_s_big);
}
- /* "netCDF4/_netCDF4.pyx":3026
+ /* "netCDF4/_netCDF4.pyx":3036
* if dtype_endian == '=': dtype_endian='native'
* if dtype_endian == '>': dtype_endian='big'
* if dtype_endian == '<': dtype_endian='little' # <<<<<<<<<<<<<<
* if dtype_endian == '|': dtype_endian=None
* if dtype_endian is not None and dtype_endian != endian:
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_kp_s__14, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3026; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_kp_s__14, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3036, __pyx_L1_error)
if (__pyx_t_2) {
__Pyx_INCREF(__pyx_n_s_little);
__Pyx_DECREF_SET(__pyx_v_dtype_endian, __pyx_n_s_little);
}
- /* "netCDF4/_netCDF4.pyx":3027
+ /* "netCDF4/_netCDF4.pyx":3037
* if dtype_endian == '>': dtype_endian='big'
* if dtype_endian == '<': dtype_endian='little'
* if dtype_endian == '|': dtype_endian=None # <<<<<<<<<<<<<<
* if dtype_endian is not None and dtype_endian != endian:
* if dtype_endian == 'native' and endian == sys.byteorder:
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_kp_s__37, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_kp_s__37, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3037, __pyx_L1_error)
if (__pyx_t_2) {
__Pyx_INCREF(Py_None);
__Pyx_DECREF_SET(__pyx_v_dtype_endian, Py_None);
}
- /* "netCDF4/_netCDF4.pyx":3028
+ /* "netCDF4/_netCDF4.pyx":3038
* if dtype_endian == '<': dtype_endian='little'
* if dtype_endian == '|': dtype_endian=None
* if dtype_endian is not None and dtype_endian != endian: # <<<<<<<<<<<<<<
@@ -26690,34 +26626,34 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = __pyx_t_8;
goto __pyx_L26_bool_binop_done;
}
- __pyx_t_3 = PyObject_RichCompare(__pyx_v_dtype_endian, __pyx_v_endian, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3028; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3028; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_dtype_endian, __pyx_v_endian, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3038, __pyx_L1_error)
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3038, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __pyx_t_8;
__pyx_L26_bool_binop_done:;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3029
+ /* "netCDF4/_netCDF4.pyx":3039
* if dtype_endian == '|': dtype_endian=None
* if dtype_endian is not None and dtype_endian != endian:
* if dtype_endian == 'native' and endian == sys.byteorder: # <<<<<<<<<<<<<<
* pass
* else:
*/
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_n_s_native, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3029; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_v_dtype_endian, __pyx_n_s_native, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3039, __pyx_L1_error)
if (__pyx_t_8) {
} else {
__pyx_t_2 = __pyx_t_8;
goto __pyx_L29_bool_binop_done;
}
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3029; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3039, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3029; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3039, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyObject_RichCompare(__pyx_v_endian, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3029; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_endian, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3039, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3029; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3039, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __pyx_t_8;
__pyx_L29_bool_binop_done:;
@@ -26725,7 +26661,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L28;
}
- /* "netCDF4/_netCDF4.pyx":3033
+ /* "netCDF4/_netCDF4.pyx":3043
* else:
* # endian keyword prevails, issue warning
* msg = 'endian-ness of dtype and endian kwarg do not match, using endian kwarg' # <<<<<<<<<<<<<<
@@ -26736,16 +26672,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(__pyx_kp_s_endian_ness_of_dtype_and_endian);
__pyx_v_msg = __pyx_kp_s_endian_ness_of_dtype_and_endian;
- /* "netCDF4/_netCDF4.pyx":3035
+ /* "netCDF4/_netCDF4.pyx":3045
* msg = 'endian-ness of dtype and endian kwarg do not match, using endian kwarg'
* #msg = 'endian-ness of dtype and endian kwarg do not match, dtype over-riding endian kwarg'
* warnings.warn(msg) # <<<<<<<<<<<<<<
* #endian = dtype_endian # dtype prevails
* # check validity of datatype.
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_warn); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_warn); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = NULL;
@@ -26759,16 +26695,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (!__pyx_t_7) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_msg); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_msg); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_msg);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -26777,7 +26713,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L28:;
- /* "netCDF4/_netCDF4.pyx":3028
+ /* "netCDF4/_netCDF4.pyx":3038
* if dtype_endian == '<': dtype_endian='little'
* if dtype_endian == '|': dtype_endian=None
* if dtype_endian is not None and dtype_endian != endian: # <<<<<<<<<<<<<<
@@ -26786,7 +26722,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3038
+ /* "netCDF4/_netCDF4.pyx":3048
* #endian = dtype_endian # dtype prevails
* # check validity of datatype.
* self._isprimitive = False # <<<<<<<<<<<<<<
@@ -26799,7 +26735,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_isprimitive);
__pyx_v_self->_isprimitive = Py_False;
- /* "netCDF4/_netCDF4.pyx":3039
+ /* "netCDF4/_netCDF4.pyx":3049
* # check validity of datatype.
* self._isprimitive = False
* self._iscompound = False # <<<<<<<<<<<<<<
@@ -26812,7 +26748,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_iscompound);
__pyx_v_self->_iscompound = Py_False;
- /* "netCDF4/_netCDF4.pyx":3040
+ /* "netCDF4/_netCDF4.pyx":3050
* self._isprimitive = False
* self._iscompound = False
* self._isvlen = False # <<<<<<<<<<<<<<
@@ -26825,7 +26761,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_isvlen);
__pyx_v_self->_isvlen = Py_False;
- /* "netCDF4/_netCDF4.pyx":3041
+ /* "netCDF4/_netCDF4.pyx":3051
* self._iscompound = False
* self._isvlen = False
* self._isenum = False # <<<<<<<<<<<<<<
@@ -26838,17 +26774,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_isenum);
__pyx_v_self->_isenum = Py_False;
- /* "netCDF4/_netCDF4.pyx":3042
+ /* "netCDF4/_netCDF4.pyx":3052
* self._isvlen = False
* self._isenum = False
* if user_type: # <<<<<<<<<<<<<<
* if isinstance(datatype, CompoundType):
* self._iscompound = True
*/
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_user_type); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3042; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_user_type); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3052, __pyx_L1_error)
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3043
+ /* "netCDF4/_netCDF4.pyx":3053
* self._isenum = False
* if user_type:
* if isinstance(datatype, CompoundType): # <<<<<<<<<<<<<<
@@ -26859,7 +26795,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = (__pyx_t_2 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3044
+ /* "netCDF4/_netCDF4.pyx":3054
* if user_type:
* if isinstance(datatype, CompoundType):
* self._iscompound = True # <<<<<<<<<<<<<<
@@ -26872,7 +26808,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_iscompound);
__pyx_v_self->_iscompound = Py_True;
- /* "netCDF4/_netCDF4.pyx":3045
+ /* "netCDF4/_netCDF4.pyx":3055
* if isinstance(datatype, CompoundType):
* self._iscompound = True
* self._cmptype = datatype # <<<<<<<<<<<<<<
@@ -26885,7 +26821,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_cmptype);
__pyx_v_self->_cmptype = __pyx_v_datatype;
- /* "netCDF4/_netCDF4.pyx":3043
+ /* "netCDF4/_netCDF4.pyx":3053
* self._isenum = False
* if user_type:
* if isinstance(datatype, CompoundType): # <<<<<<<<<<<<<<
@@ -26894,7 +26830,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3046
+ /* "netCDF4/_netCDF4.pyx":3056
* self._iscompound = True
* self._cmptype = datatype
* if isinstance(datatype, VLType) or datatype==str: # <<<<<<<<<<<<<<
@@ -26908,14 +26844,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = __pyx_t_1;
goto __pyx_L34_bool_binop_done;
}
- __pyx_t_3 = PyObject_RichCompare(__pyx_v_datatype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_datatype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3056, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3056, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_8 = __pyx_t_1;
__pyx_L34_bool_binop_done:;
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3047
+ /* "netCDF4/_netCDF4.pyx":3057
* self._cmptype = datatype
* if isinstance(datatype, VLType) or datatype==str:
* self._isvlen = True # <<<<<<<<<<<<<<
@@ -26928,7 +26864,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_isvlen);
__pyx_v_self->_isvlen = Py_True;
- /* "netCDF4/_netCDF4.pyx":3048
+ /* "netCDF4/_netCDF4.pyx":3058
* if isinstance(datatype, VLType) or datatype==str:
* self._isvlen = True
* self._vltype = datatype # <<<<<<<<<<<<<<
@@ -26941,7 +26877,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_vltype);
__pyx_v_self->_vltype = __pyx_v_datatype;
- /* "netCDF4/_netCDF4.pyx":3046
+ /* "netCDF4/_netCDF4.pyx":3056
* self._iscompound = True
* self._cmptype = datatype
* if isinstance(datatype, VLType) or datatype==str: # <<<<<<<<<<<<<<
@@ -26950,7 +26886,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3049
+ /* "netCDF4/_netCDF4.pyx":3059
* self._isvlen = True
* self._vltype = datatype
* if isinstance(datatype, EnumType): # <<<<<<<<<<<<<<
@@ -26961,7 +26897,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_1 = (__pyx_t_8 != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3050
+ /* "netCDF4/_netCDF4.pyx":3060
* self._vltype = datatype
* if isinstance(datatype, EnumType):
* self._isenum = True # <<<<<<<<<<<<<<
@@ -26974,7 +26910,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_isenum);
__pyx_v_self->_isenum = Py_True;
- /* "netCDF4/_netCDF4.pyx":3051
+ /* "netCDF4/_netCDF4.pyx":3061
* if isinstance(datatype, EnumType):
* self._isenum = True
* self._enumtype = datatype # <<<<<<<<<<<<<<
@@ -26987,7 +26923,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_enumtype);
__pyx_v_self->_enumtype = __pyx_v_datatype;
- /* "netCDF4/_netCDF4.pyx":3049
+ /* "netCDF4/_netCDF4.pyx":3059
* self._isvlen = True
* self._vltype = datatype
* if isinstance(datatype, EnumType): # <<<<<<<<<<<<<<
@@ -26996,45 +26932,45 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3052
+ /* "netCDF4/_netCDF4.pyx":3062
* self._isenum = True
* self._enumtype = datatype
* if datatype==str: # <<<<<<<<<<<<<<
* if grp.data_model != 'NETCDF4':
* raise ValueError(
*/
- __pyx_t_3 = PyObject_RichCompare(__pyx_v_datatype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3052; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3052; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_datatype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3062, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3062, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3053
+ /* "netCDF4/_netCDF4.pyx":3063
* self._enumtype = datatype
* if datatype==str:
* if grp.data_model != 'NETCDF4': # <<<<<<<<<<<<<<
* raise ValueError(
* 'Variable length strings are only supported for the '
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3063, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3063, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3054
+ /* "netCDF4/_netCDF4.pyx":3064
* if datatype==str:
* if grp.data_model != 'NETCDF4':
* raise ValueError( # <<<<<<<<<<<<<<
* 'Variable length strings are only supported for the '
* 'NETCDF4 format. For other formats, consider using '
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3064, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3064, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3053
+ /* "netCDF4/_netCDF4.pyx":3063
* self._enumtype = datatype
* if datatype==str:
* if grp.data_model != 'NETCDF4': # <<<<<<<<<<<<<<
@@ -27043,14 +26979,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3059
+ /* "netCDF4/_netCDF4.pyx":3069
* 'netCDF4.stringtochar to convert string arrays into '
* 'character arrays with an additional dimension.')
* datatype = VLType(self._grp, str, None) # <<<<<<<<<<<<<<
* self._vltype = datatype
* xtype = datatype._nc_type
*/
- __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3069, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_self->_grp);
__Pyx_GIVEREF(__pyx_v_self->_grp);
@@ -27061,13 +26997,13 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_3, 2, Py_None);
- __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_VLType), __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_VLType), __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3069, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_datatype, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3060
+ /* "netCDF4/_netCDF4.pyx":3070
* 'character arrays with an additional dimension.')
* datatype = VLType(self._grp, str, None)
* self._vltype = datatype # <<<<<<<<<<<<<<
@@ -27080,7 +27016,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_vltype);
__pyx_v_self->_vltype = __pyx_v_datatype;
- /* "netCDF4/_netCDF4.pyx":3052
+ /* "netCDF4/_netCDF4.pyx":3062
* self._isenum = True
* self._enumtype = datatype
* if datatype==str: # <<<<<<<<<<<<<<
@@ -27089,27 +27025,27 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3061
+ /* "netCDF4/_netCDF4.pyx":3071
* datatype = VLType(self._grp, str, None)
* self._vltype = datatype
* xtype = datatype._nc_type # <<<<<<<<<<<<<<
* # dtype variable attribute is a numpy datatype object.
* self.dtype = datatype.dtype
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_nc_type); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_nc_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3071, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_9 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_9 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_9 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 3071, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_xtype = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":3063
+ /* "netCDF4/_netCDF4.pyx":3073
* xtype = datatype._nc_type
* # dtype variable attribute is a numpy datatype object.
* self.dtype = datatype.dtype # <<<<<<<<<<<<<<
* elif datatype.str[1:] in _supportedtypes:
* self._isprimitive = True
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3063; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3073, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_v_self->dtype);
@@ -27117,7 +27053,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_v_self->dtype = __pyx_t_5;
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3042
+ /* "netCDF4/_netCDF4.pyx":3052
* self._isvlen = False
* self._isenum = False
* if user_type: # <<<<<<<<<<<<<<
@@ -27127,27 +27063,27 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L31;
}
- /* "netCDF4/_netCDF4.pyx":3064
+ /* "netCDF4/_netCDF4.pyx":3074
* # dtype variable attribute is a numpy datatype object.
* self.dtype = datatype.dtype
* elif datatype.str[1:] in _supportedtypes: # <<<<<<<<<<<<<<
* self._isprimitive = True
* # find netCDF primitive data type corresponding to
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3064; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3074, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__39, 1, 0, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3064; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__39, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3074, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3064; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3074, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3064; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_3, __pyx_t_5, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3074, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_8 = (__pyx_t_1 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3065
+ /* "netCDF4/_netCDF4.pyx":3075
* self.dtype = datatype.dtype
* elif datatype.str[1:] in _supportedtypes:
* self._isprimitive = True # <<<<<<<<<<<<<<
@@ -27160,29 +27096,29 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_isprimitive);
__pyx_v_self->_isprimitive = Py_True;
- /* "netCDF4/_netCDF4.pyx":3068
+ /* "netCDF4/_netCDF4.pyx":3078
* # find netCDF primitive data type corresponding to
* # specified numpy data type.
* xtype = _nptonctype[datatype.str[1:]] # <<<<<<<<<<<<<<
* # dtype variable attribute is a numpy datatype object.
* self.dtype = datatype
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3068; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3078, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_str); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3068; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_datatype, __pyx_n_s_str); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3078, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyObject_GetSlice(__pyx_t_3, 1, 0, NULL, NULL, &__pyx_slice__40, 1, 0, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3068; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetSlice(__pyx_t_3, 1, 0, NULL, NULL, &__pyx_slice__40, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3078, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3068; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3078, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_9 = __Pyx_PyInt_As_nc_type(__pyx_t_3); if (unlikely((__pyx_t_9 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3068; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_nc_type(__pyx_t_3); if (unlikely((__pyx_t_9 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 3078, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_xtype = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":3070
+ /* "netCDF4/_netCDF4.pyx":3080
* xtype = _nptonctype[datatype.str[1:]]
* # dtype variable attribute is a numpy datatype object.
* self.dtype = datatype # <<<<<<<<<<<<<<
@@ -27195,7 +27131,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->dtype);
__pyx_v_self->dtype = __pyx_v_datatype;
- /* "netCDF4/_netCDF4.pyx":3064
+ /* "netCDF4/_netCDF4.pyx":3074
* # dtype variable attribute is a numpy datatype object.
* self.dtype = datatype.dtype
* elif datatype.str[1:] in _supportedtypes: # <<<<<<<<<<<<<<
@@ -27205,7 +27141,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L31;
}
- /* "netCDF4/_netCDF4.pyx":3072
+ /* "netCDF4/_netCDF4.pyx":3082
* self.dtype = datatype
* else:
* raise TypeError('illegal primitive data type, must be one of %s, got %s' % (_supportedtypes,datatype)) # <<<<<<<<<<<<<<
@@ -27213,9 +27149,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* self._varid = kwargs['id']
*/
/*else*/ {
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3072; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3082, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3072; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3082, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
@@ -27223,48 +27159,48 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_GIVEREF(__pyx_v_datatype);
PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_datatype);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_illegal_primitive_data_type_must, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3072; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_illegal_primitive_data_type_must, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3082, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3072; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3082, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3072; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3082, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3072; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3082, __pyx_L1_error)
}
__pyx_L31:;
- /* "netCDF4/_netCDF4.pyx":3073
+ /* "netCDF4/_netCDF4.pyx":3083
* else:
* raise TypeError('illegal primitive data type, must be one of %s, got %s' % (_supportedtypes,datatype))
* if 'id' in kwargs: # <<<<<<<<<<<<<<
* self._varid = kwargs['id']
* else:
*/
- __pyx_t_8 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_id, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3073; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_id, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3083, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_8 != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3074
+ /* "netCDF4/_netCDF4.pyx":3084
* raise TypeError('illegal primitive data type, must be one of %s, got %s' % (_supportedtypes,datatype))
* if 'id' in kwargs:
* self._varid = kwargs['id'] # <<<<<<<<<<<<<<
* else:
* bytestr = _strencode(name)
*/
- __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_id); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3074; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_id); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3084, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3074; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3084, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_self->_varid = __pyx_t_4;
- /* "netCDF4/_netCDF4.pyx":3073
+ /* "netCDF4/_netCDF4.pyx":3083
* else:
* raise TypeError('illegal primitive data type, must be one of %s, got %s' % (_supportedtypes,datatype))
* if 'id' in kwargs: # <<<<<<<<<<<<<<
@@ -27274,7 +27210,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L39;
}
- /* "netCDF4/_netCDF4.pyx":3076
+ /* "netCDF4/_netCDF4.pyx":3086
* self._varid = kwargs['id']
* else:
* bytestr = _strencode(name) # <<<<<<<<<<<<<<
@@ -27282,32 +27218,32 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* ndims = len(dimensions)
*/
/*else*/ {
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3076; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3086, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_bytestr = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3077
+ /* "netCDF4/_netCDF4.pyx":3087
* else:
* bytestr = _strencode(name)
* varname = bytestr # <<<<<<<<<<<<<<
* ndims = len(dimensions)
* # find dimension ids.
*/
- __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3077; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_10) && PyErr_Occurred())) __PYX_ERR(0, 3087, __pyx_L1_error)
__pyx_v_varname = __pyx_t_10;
- /* "netCDF4/_netCDF4.pyx":3078
+ /* "netCDF4/_netCDF4.pyx":3088
* bytestr = _strencode(name)
* varname = bytestr
* ndims = len(dimensions) # <<<<<<<<<<<<<<
* # find dimension ids.
* if ndims:
*/
- __pyx_t_11 = PyObject_Length(__pyx_v_dimensions); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3078; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyObject_Length(__pyx_v_dimensions); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3088, __pyx_L1_error)
__pyx_v_ndims = __pyx_t_11;
- /* "netCDF4/_netCDF4.pyx":3080
+ /* "netCDF4/_netCDF4.pyx":3090
* ndims = len(dimensions)
* # find dimension ids.
* if ndims: # <<<<<<<<<<<<<<
@@ -27317,19 +27253,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_1 = (__pyx_v_ndims != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3081
+ /* "netCDF4/_netCDF4.pyx":3091
* # find dimension ids.
* if ndims:
* dims = [] # <<<<<<<<<<<<<<
* dimids = <int *>malloc(sizeof(int) * ndims)
* for n from 0 <= n < ndims:
*/
- __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3081; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3091, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_dims = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3082
+ /* "netCDF4/_netCDF4.pyx":3092
* if ndims:
* dims = []
* dimids = <int *>malloc(sizeof(int) * ndims) # <<<<<<<<<<<<<<
@@ -27338,7 +27274,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_dimids = ((int *)malloc(((sizeof(int)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":3083
+ /* "netCDF4/_netCDF4.pyx":3093
* dims = []
* dimids = <int *>malloc(sizeof(int) * ndims)
* for n from 0 <= n < ndims: # <<<<<<<<<<<<<<
@@ -27348,26 +27284,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_4 = __pyx_v_ndims;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_4; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":3084
+ /* "netCDF4/_netCDF4.pyx":3094
* dimids = <int *>malloc(sizeof(int) * ndims)
* for n from 0 <= n < ndims:
* dimname = dimensions[n] # <<<<<<<<<<<<<<
* # look for dimension in this group, and if not
* # found there, look in parent (and it's parent, etc, back to root).
*/
- __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_dimensions, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3084; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_dimensions, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3094, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3087
+ /* "netCDF4/_netCDF4.pyx":3097
* # look for dimension in this group, and if not
* # found there, look in parent (and it's parent, etc, back to root).
* dim = _find_dim(grp, dimname) # <<<<<<<<<<<<<<
* if dim is None:
* raise KeyError("dimension %s not defined in group %s or any group in it's family tree" % (dimname, grp.path))
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3087; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3097, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_5 = NULL;
__pyx_t_11 = 0;
@@ -27381,7 +27317,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_11 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3087; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3097, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
@@ -27392,14 +27328,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_11, __pyx_v_dimname);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3087; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3097, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF_SET(__pyx_v_dim, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3088
+ /* "netCDF4/_netCDF4.pyx":3098
* # found there, look in parent (and it's parent, etc, back to root).
* dim = _find_dim(grp, dimname)
* if dim is None: # <<<<<<<<<<<<<<
@@ -27410,16 +27346,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = (__pyx_t_1 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3089
+ /* "netCDF4/_netCDF4.pyx":3099
* dim = _find_dim(grp, dimname)
* if dim is None:
* raise KeyError("dimension %s not defined in group %s or any group in it's family tree" % (dimname, grp.path)) # <<<<<<<<<<<<<<
* dimids[n] = dim._dimid
* dims.append(dim)
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_path); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3089; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3099, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3089; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3099, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
@@ -27427,22 +27363,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_dimension_s_not_defined_in_group, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3089; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_dimension_s_not_defined_in_group, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3099, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3089; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3099, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3089; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3099, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3089; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3099, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3088
+ /* "netCDF4/_netCDF4.pyx":3098
* # found there, look in parent (and it's parent, etc, back to root).
* dim = _find_dim(grp, dimname)
* if dim is None: # <<<<<<<<<<<<<<
@@ -27451,30 +27387,30 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3090
+ /* "netCDF4/_netCDF4.pyx":3100
* if dim is None:
* raise KeyError("dimension %s not defined in group %s or any group in it's family tree" % (dimname, grp.path))
* dimids[n] = dim._dimid # <<<<<<<<<<<<<<
* dims.append(dim)
* # go into define mode if it's a netCDF 3 compatible
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_dimid); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3090; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_dimid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3100, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3090; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3100, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
(__pyx_v_dimids[__pyx_v_n]) = __pyx_t_12;
- /* "netCDF4/_netCDF4.pyx":3091
+ /* "netCDF4/_netCDF4.pyx":3101
* raise KeyError("dimension %s not defined in group %s or any group in it's family tree" % (dimname, grp.path))
* dimids[n] = dim._dimid
* dims.append(dim) # <<<<<<<<<<<<<<
* # go into define mode if it's a netCDF 3 compatible
* # file format. Be careful to exit define mode before
*/
- __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_dims, __pyx_v_dim); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3091; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_dims, __pyx_v_dim); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 3101, __pyx_L1_error)
}
- /* "netCDF4/_netCDF4.pyx":3080
+ /* "netCDF4/_netCDF4.pyx":3090
* ndims = len(dimensions)
* # find dimension ids.
* if ndims: # <<<<<<<<<<<<<<
@@ -27483,19 +27419,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3095
+ /* "netCDF4/_netCDF4.pyx":3105
* # file format. Be careful to exit define mode before
* # any exceptions are raised.
* if grp.data_model != 'NETCDF4': grp._redef() # <<<<<<<<<<<<<<
* # define variable.
* if ndims:
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3105, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3105, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_8) {
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3105, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -27508,17 +27444,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_7) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3105, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3105, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3097
+ /* "netCDF4/_netCDF4.pyx":3107
* if grp.data_model != 'NETCDF4': grp._redef()
* # define variable.
* if ndims: # <<<<<<<<<<<<<<
@@ -27528,7 +27464,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = (__pyx_v_ndims != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3098
+ /* "netCDF4/_netCDF4.pyx":3108
* # define variable.
* if ndims:
* ierr = nc_def_var(self._grpid, varname, xtype, ndims, # <<<<<<<<<<<<<<
@@ -27537,7 +27473,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = nc_def_var(__pyx_v_self->_grpid, __pyx_v_varname, __pyx_v_xtype, __pyx_v_ndims, __pyx_v_dimids, (&__pyx_v_self->_varid));
- /* "netCDF4/_netCDF4.pyx":3100
+ /* "netCDF4/_netCDF4.pyx":3110
* ierr = nc_def_var(self._grpid, varname, xtype, ndims,
* dimids, &self._varid)
* free(dimids) # <<<<<<<<<<<<<<
@@ -27546,7 +27482,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
free(__pyx_v_dimids);
- /* "netCDF4/_netCDF4.pyx":3097
+ /* "netCDF4/_netCDF4.pyx":3107
* if grp.data_model != 'NETCDF4': grp._redef()
* # define variable.
* if ndims: # <<<<<<<<<<<<<<
@@ -27556,7 +27492,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L45;
}
- /* "netCDF4/_netCDF4.pyx":3102
+ /* "netCDF4/_netCDF4.pyx":3112
* free(dimids)
* else: # a scalar variable.
* ierr = nc_def_var(self._grpid, varname, xtype, ndims, # <<<<<<<<<<<<<<
@@ -27565,7 +27501,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
/*else*/ {
- /* "netCDF4/_netCDF4.pyx":3103
+ /* "netCDF4/_netCDF4.pyx":3113
* else: # a scalar variable.
* ierr = nc_def_var(self._grpid, varname, xtype, ndims,
* NULL, &self._varid) # <<<<<<<<<<<<<<
@@ -27576,22 +27512,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L45:;
- /* "netCDF4/_netCDF4.pyx":3108
+ /* "netCDF4/_netCDF4.pyx":3118
* # of vars are created. This change only lasts as long as file is
* # open.
* if grp.data_model.startswith('NETCDF4') and chunk_cache is not None: # <<<<<<<<<<<<<<
* ierr = nc_get_var_chunk_cache(self._grpid, self._varid, &sizep,
* &nelemsp, &preemptionp)
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3118, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_startswith); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_startswith); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3118, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3118, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3118, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_1) {
} else {
@@ -27604,7 +27540,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_L47_bool_binop_done:;
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3109
+ /* "netCDF4/_netCDF4.pyx":3119
* # open.
* if grp.data_model.startswith('NETCDF4') and chunk_cache is not None:
* ierr = nc_get_var_chunk_cache(self._grpid, self._varid, &sizep, # <<<<<<<<<<<<<<
@@ -27613,7 +27549,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = nc_get_var_chunk_cache(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_sizep), (&__pyx_v_nelemsp), (&__pyx_v_preemptionp));
- /* "netCDF4/_netCDF4.pyx":3111
+ /* "netCDF4/_netCDF4.pyx":3121
* ierr = nc_get_var_chunk_cache(self._grpid, self._varid, &sizep,
* &nelemsp, &preemptionp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -27623,7 +27559,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3112
+ /* "netCDF4/_netCDF4.pyx":3122
* &nelemsp, &preemptionp)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -27631,22 +27567,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* sizep = chunk_cache
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3112; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3122, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3112; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3122, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3112; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3122, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3112; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3122, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3111
+ /* "netCDF4/_netCDF4.pyx":3121
* ierr = nc_get_var_chunk_cache(self._grpid, self._varid, &sizep,
* &nelemsp, &preemptionp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -27655,17 +27591,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3114
+ /* "netCDF4/_netCDF4.pyx":3124
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # reset chunk cache size, leave other parameters unchanged.
* sizep = chunk_cache # <<<<<<<<<<<<<<
* ierr = nc_set_var_chunk_cache(self._grpid, self._varid, sizep,
* nelemsp, preemptionp)
*/
- __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_chunk_cache); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3114; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_v_chunk_cache); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3124, __pyx_L1_error)
__pyx_v_sizep = __pyx_t_14;
- /* "netCDF4/_netCDF4.pyx":3115
+ /* "netCDF4/_netCDF4.pyx":3125
* # reset chunk cache size, leave other parameters unchanged.
* sizep = chunk_cache
* ierr = nc_set_var_chunk_cache(self._grpid, self._varid, sizep, # <<<<<<<<<<<<<<
@@ -27674,7 +27610,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = nc_set_var_chunk_cache(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_sizep, __pyx_v_nelemsp, __pyx_v_preemptionp);
- /* "netCDF4/_netCDF4.pyx":3117
+ /* "netCDF4/_netCDF4.pyx":3127
* ierr = nc_set_var_chunk_cache(self._grpid, self._varid, sizep,
* nelemsp, preemptionp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -27684,7 +27620,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3118
+ /* "netCDF4/_netCDF4.pyx":3128
* nelemsp, preemptionp)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -27692,22 +27628,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* if grp.data_model != 'NETCDF4': grp._enddef()
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3118; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3128, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3118; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3128, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3118; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3128, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3118; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3128, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3117
+ /* "netCDF4/_netCDF4.pyx":3127
* ierr = nc_set_var_chunk_cache(self._grpid, self._varid, sizep,
* nelemsp, preemptionp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -27716,7 +27652,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3108
+ /* "netCDF4/_netCDF4.pyx":3118
* # of vars are created. This change only lasts as long as file is
* # open.
* if grp.data_model.startswith('NETCDF4') and chunk_cache is not None: # <<<<<<<<<<<<<<
@@ -27725,7 +27661,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3119
+ /* "netCDF4/_netCDF4.pyx":3129
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -27735,19 +27671,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3120
+ /* "netCDF4/_netCDF4.pyx":3130
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set zlib, shuffle, chunking, fletcher32 and endian
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3120; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3120; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3130, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_8) {
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3120; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -27760,17 +27696,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_7) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3120; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3130, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3120; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3130, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3121
+ /* "netCDF4/_netCDF4.pyx":3131
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -27778,22 +27714,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* # variable settings.
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3121; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3131, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3121; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3131, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3121; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3131, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3121; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3131, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3119
+ /* "netCDF4/_netCDF4.pyx":3129
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -27802,36 +27738,36 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3128
+ /* "netCDF4/_netCDF4.pyx":3138
* # and fletcher32 are silently ignored. Only
* # endian='native' allowed for NETCDF3.
* if grp.data_model in ['NETCDF4','NETCDF4_CLASSIC']: # <<<<<<<<<<<<<<
* # set zlib and shuffle parameters.
* if zlib and ndims: # don't bother for scalar variable
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3128; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3138, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3128; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3138, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_8 = __pyx_t_2;
goto __pyx_L54_bool_binop_done;
}
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4_CLASSIC, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3128; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4_CLASSIC, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3138, __pyx_L1_error)
__pyx_t_8 = __pyx_t_2;
__pyx_L54_bool_binop_done:;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = (__pyx_t_8 != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3130
+ /* "netCDF4/_netCDF4.pyx":3140
* if grp.data_model in ['NETCDF4','NETCDF4_CLASSIC']:
* # set zlib and shuffle parameters.
* if zlib and ndims: # don't bother for scalar variable # <<<<<<<<<<<<<<
* ideflate_level = complevel
* if shuffle:
*/
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_zlib); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_zlib); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3140, __pyx_L1_error)
if (__pyx_t_8) {
} else {
__pyx_t_2 = __pyx_t_8;
@@ -27842,27 +27778,27 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_L57_bool_binop_done:;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3131
+ /* "netCDF4/_netCDF4.pyx":3141
* # set zlib and shuffle parameters.
* if zlib and ndims: # don't bother for scalar variable
* ideflate_level = complevel # <<<<<<<<<<<<<<
* if shuffle:
* ierr = nc_def_var_deflate(self._grpid, self._varid, 1, 1, ideflate_level)
*/
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_complevel); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3131; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_complevel); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3141, __pyx_L1_error)
__pyx_v_ideflate_level = __pyx_t_4;
- /* "netCDF4/_netCDF4.pyx":3132
+ /* "netCDF4/_netCDF4.pyx":3142
* if zlib and ndims: # don't bother for scalar variable
* ideflate_level = complevel
* if shuffle: # <<<<<<<<<<<<<<
* ierr = nc_def_var_deflate(self._grpid, self._varid, 1, 1, ideflate_level)
* else:
*/
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_shuffle); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3132; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_shuffle); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3142, __pyx_L1_error)
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3133
+ /* "netCDF4/_netCDF4.pyx":3143
* ideflate_level = complevel
* if shuffle:
* ierr = nc_def_var_deflate(self._grpid, self._varid, 1, 1, ideflate_level) # <<<<<<<<<<<<<<
@@ -27871,7 +27807,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = nc_def_var_deflate(__pyx_v_self->_grpid, __pyx_v_self->_varid, 1, 1, __pyx_v_ideflate_level);
- /* "netCDF4/_netCDF4.pyx":3132
+ /* "netCDF4/_netCDF4.pyx":3142
* if zlib and ndims: # don't bother for scalar variable
* ideflate_level = complevel
* if shuffle: # <<<<<<<<<<<<<<
@@ -27881,7 +27817,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L59;
}
- /* "netCDF4/_netCDF4.pyx":3135
+ /* "netCDF4/_netCDF4.pyx":3145
* ierr = nc_def_var_deflate(self._grpid, self._varid, 1, 1, ideflate_level)
* else:
* ierr = nc_def_var_deflate(self._grpid, self._varid, 0, 1, ideflate_level) # <<<<<<<<<<<<<<
@@ -27893,7 +27829,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L59:;
- /* "netCDF4/_netCDF4.pyx":3136
+ /* "netCDF4/_netCDF4.pyx":3146
* else:
* ierr = nc_def_var_deflate(self._grpid, self._varid, 0, 1, ideflate_level)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -27903,19 +27839,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3137
+ /* "netCDF4/_netCDF4.pyx":3147
* ierr = nc_def_var_deflate(self._grpid, self._varid, 0, 1, ideflate_level)
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set checksum.
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3137; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3147, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3137; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3147, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_2) {
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3137; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3147, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -27928,17 +27864,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_7) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3137; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3147, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3137; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3147, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3138
+ /* "netCDF4/_netCDF4.pyx":3148
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -27946,22 +27882,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* if fletcher32 and ndims: # don't bother for scalar variable
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3138; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3138; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3138; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3138; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3148, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3136
+ /* "netCDF4/_netCDF4.pyx":3146
* else:
* ierr = nc_def_var_deflate(self._grpid, self._varid, 0, 1, ideflate_level)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -27970,7 +27906,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3130
+ /* "netCDF4/_netCDF4.pyx":3140
* if grp.data_model in ['NETCDF4','NETCDF4_CLASSIC']:
* # set zlib and shuffle parameters.
* if zlib and ndims: # don't bother for scalar variable # <<<<<<<<<<<<<<
@@ -27979,14 +27915,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3140
+ /* "netCDF4/_netCDF4.pyx":3150
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set checksum.
* if fletcher32 and ndims: # don't bother for scalar variable # <<<<<<<<<<<<<<
* ierr = nc_def_var_fletcher32(self._grpid, self._varid, 1)
* if ierr != NC_NOERR:
*/
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_fletcher32); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3140; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_fletcher32); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3150, __pyx_L1_error)
if (__pyx_t_8) {
} else {
__pyx_t_2 = __pyx_t_8;
@@ -27997,7 +27933,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_L63_bool_binop_done:;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3141
+ /* "netCDF4/_netCDF4.pyx":3151
* # set checksum.
* if fletcher32 and ndims: # don't bother for scalar variable
* ierr = nc_def_var_fletcher32(self._grpid, self._varid, 1) # <<<<<<<<<<<<<<
@@ -28006,7 +27942,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = nc_def_var_fletcher32(__pyx_v_self->_grpid, __pyx_v_self->_varid, 1);
- /* "netCDF4/_netCDF4.pyx":3142
+ /* "netCDF4/_netCDF4.pyx":3152
* if fletcher32 and ndims: # don't bother for scalar variable
* ierr = nc_def_var_fletcher32(self._grpid, self._varid, 1)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -28016,19 +27952,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3143
+ /* "netCDF4/_netCDF4.pyx":3153
* ierr = nc_def_var_fletcher32(self._grpid, self._varid, 1)
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set chunking stuff.
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3143; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3143; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3153, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_2) {
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3143; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -28041,17 +27977,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_7) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3143; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3153, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3143; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3153, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3144
+ /* "netCDF4/_netCDF4.pyx":3154
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -28059,22 +27995,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* if ndims: # don't bother for scalar variable.
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3144; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3154, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3144; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3154, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3144; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3154, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3144; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3154, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3142
+ /* "netCDF4/_netCDF4.pyx":3152
* if fletcher32 and ndims: # don't bother for scalar variable
* ierr = nc_def_var_fletcher32(self._grpid, self._varid, 1)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -28083,7 +28019,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3140
+ /* "netCDF4/_netCDF4.pyx":3150
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set checksum.
* if fletcher32 and ndims: # don't bother for scalar variable # <<<<<<<<<<<<<<
@@ -28092,7 +28028,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3146
+ /* "netCDF4/_netCDF4.pyx":3156
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set chunking stuff.
* if ndims: # don't bother for scalar variable. # <<<<<<<<<<<<<<
@@ -28102,17 +28038,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = (__pyx_v_ndims != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3147
+ /* "netCDF4/_netCDF4.pyx":3157
* # set chunking stuff.
* if ndims: # don't bother for scalar variable.
* if contiguous: # <<<<<<<<<<<<<<
* icontiguous = NC_CONTIGUOUS
* if chunksizes is not None:
*/
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_contiguous); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3147; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_contiguous); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3157, __pyx_L1_error)
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3148
+ /* "netCDF4/_netCDF4.pyx":3158
* if ndims: # don't bother for scalar variable.
* if contiguous:
* icontiguous = NC_CONTIGUOUS # <<<<<<<<<<<<<<
@@ -28121,7 +28057,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_icontiguous = NC_CONTIGUOUS;
- /* "netCDF4/_netCDF4.pyx":3149
+ /* "netCDF4/_netCDF4.pyx":3159
* if contiguous:
* icontiguous = NC_CONTIGUOUS
* if chunksizes is not None: # <<<<<<<<<<<<<<
@@ -28132,20 +28068,20 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = (__pyx_t_2 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3150
+ /* "netCDF4/_netCDF4.pyx":3160
* icontiguous = NC_CONTIGUOUS
* if chunksizes is not None:
* raise ValueError('cannot specify chunksizes for a contiguous dataset') # <<<<<<<<<<<<<<
* else:
* icontiguous = NC_CHUNKED
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3160, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3160, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3149
+ /* "netCDF4/_netCDF4.pyx":3159
* if contiguous:
* icontiguous = NC_CONTIGUOUS
* if chunksizes is not None: # <<<<<<<<<<<<<<
@@ -28154,7 +28090,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3147
+ /* "netCDF4/_netCDF4.pyx":3157
* # set chunking stuff.
* if ndims: # don't bother for scalar variable.
* if contiguous: # <<<<<<<<<<<<<<
@@ -28164,7 +28100,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L68;
}
- /* "netCDF4/_netCDF4.pyx":3152
+ /* "netCDF4/_netCDF4.pyx":3162
* raise ValueError('cannot specify chunksizes for a contiguous dataset')
* else:
* icontiguous = NC_CHUNKED # <<<<<<<<<<<<<<
@@ -28176,7 +28112,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L68:;
- /* "netCDF4/_netCDF4.pyx":3153
+ /* "netCDF4/_netCDF4.pyx":3163
* else:
* icontiguous = NC_CHUNKED
* if chunksizes is None: # <<<<<<<<<<<<<<
@@ -28187,7 +28123,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = (__pyx_t_8 != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3154
+ /* "netCDF4/_netCDF4.pyx":3164
* icontiguous = NC_CHUNKED
* if chunksizes is None:
* chunksizesp = NULL # <<<<<<<<<<<<<<
@@ -28196,7 +28132,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_chunksizesp = NULL;
- /* "netCDF4/_netCDF4.pyx":3153
+ /* "netCDF4/_netCDF4.pyx":3163
* else:
* icontiguous = NC_CHUNKED
* if chunksizes is None: # <<<<<<<<<<<<<<
@@ -28206,7 +28142,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L70;
}
- /* "netCDF4/_netCDF4.pyx":3156
+ /* "netCDF4/_netCDF4.pyx":3166
* chunksizesp = NULL
* else:
* if len(chunksizes) != len(dimensions): # <<<<<<<<<<<<<<
@@ -28214,24 +28150,24 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* raise ValueError('chunksizes must be a sequence with the same length as dimensions')
*/
/*else*/ {
- __pyx_t_11 = PyObject_Length(__pyx_v_chunksizes); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3156; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_15 = PyObject_Length(__pyx_v_dimensions); if (unlikely(__pyx_t_15 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3156; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyObject_Length(__pyx_v_chunksizes); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3166, __pyx_L1_error)
+ __pyx_t_15 = PyObject_Length(__pyx_v_dimensions); if (unlikely(__pyx_t_15 == -1)) __PYX_ERR(0, 3166, __pyx_L1_error)
__pyx_t_2 = ((__pyx_t_11 != __pyx_t_15) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3157
+ /* "netCDF4/_netCDF4.pyx":3167
* else:
* if len(chunksizes) != len(dimensions):
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* raise ValueError('chunksizes must be a sequence with the same length as dimensions')
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3157; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3167, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3157; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3167, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_2) {
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3157; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3167, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -28244,30 +28180,30 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_7) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3157; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3167, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3157; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3167, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3158
+ /* "netCDF4/_netCDF4.pyx":3168
* if len(chunksizes) != len(dimensions):
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise ValueError('chunksizes must be a sequence with the same length as dimensions') # <<<<<<<<<<<<<<
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* for n from 0 <= n < ndims:
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3158; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3168, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3158; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3168, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3156
+ /* "netCDF4/_netCDF4.pyx":3166
* chunksizesp = NULL
* else:
* if len(chunksizes) != len(dimensions): # <<<<<<<<<<<<<<
@@ -28276,7 +28212,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3159
+ /* "netCDF4/_netCDF4.pyx":3169
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise ValueError('chunksizes must be a sequence with the same length as dimensions')
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims) # <<<<<<<<<<<<<<
@@ -28285,7 +28221,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_chunksizesp = ((size_t *)malloc(((sizeof(size_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":3160
+ /* "netCDF4/_netCDF4.pyx":3170
* raise ValueError('chunksizes must be a sequence with the same length as dimensions')
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* for n from 0 <= n < ndims: # <<<<<<<<<<<<<<
@@ -28295,17 +28231,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_4 = __pyx_v_ndims;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_4; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":3161
+ /* "netCDF4/_netCDF4.pyx":3171
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* for n from 0 <= n < ndims:
* if not dims[n].isunlimited() and \ # <<<<<<<<<<<<<<
* chunksizes[n] > dims[n].size:
* msg = 'chunksize cannot exceed dimension size'
*/
- if (unlikely(!__pyx_v_dims)) { __Pyx_RaiseUnboundLocalError("dims"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3161; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_dims, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3161; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ if (unlikely(!__pyx_v_dims)) { __Pyx_RaiseUnboundLocalError("dims"); __PYX_ERR(0, 3171, __pyx_L1_error) }
+ __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_dims, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3171, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3161; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3171, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -28319,14 +28255,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_6) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3161; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3171, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3161; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3171, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3161; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3171, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_1 = ((!__pyx_t_8) != 0);
if (__pyx_t_1) {
@@ -28335,30 +28271,30 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L76_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":3162
+ /* "netCDF4/_netCDF4.pyx":3172
* for n from 0 <= n < ndims:
* if not dims[n].isunlimited() and \
* chunksizes[n] > dims[n].size: # <<<<<<<<<<<<<<
* msg = 'chunksize cannot exceed dimension size'
* raise ValueError(msg)
*/
- __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_chunksizes, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3162; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_chunksizes, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3172, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- if (unlikely(!__pyx_v_dims)) { __Pyx_RaiseUnboundLocalError("dims"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3162; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_dims, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3162; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ if (unlikely(!__pyx_v_dims)) { __Pyx_RaiseUnboundLocalError("dims"); __PYX_ERR(0, 3172, __pyx_L1_error) }
+ __pyx_t_7 = __Pyx_GetItemInt_List(__pyx_v_dims, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3172, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_size); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3162; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3172, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3162; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_t_6, Py_GT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3172, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3162; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3172, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_2 = __pyx_t_1;
__pyx_L76_bool_binop_done:;
- /* "netCDF4/_netCDF4.pyx":3161
+ /* "netCDF4/_netCDF4.pyx":3171
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* for n from 0 <= n < ndims:
* if not dims[n].isunlimited() and \ # <<<<<<<<<<<<<<
@@ -28367,7 +28303,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3163
+ /* "netCDF4/_netCDF4.pyx":3173
* if not dims[n].isunlimited() and \
* chunksizes[n] > dims[n].size:
* msg = 'chunksize cannot exceed dimension size' # <<<<<<<<<<<<<<
@@ -28377,26 +28313,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(__pyx_kp_s_chunksize_cannot_exceed_dimensio);
__Pyx_XDECREF_SET(__pyx_v_msg, __pyx_kp_s_chunksize_cannot_exceed_dimensio);
- /* "netCDF4/_netCDF4.pyx":3164
+ /* "netCDF4/_netCDF4.pyx":3174
* chunksizes[n] > dims[n].size:
* msg = 'chunksize cannot exceed dimension size'
* raise ValueError(msg) # <<<<<<<<<<<<<<
* chunksizesp[n] = chunksizes[n]
* if chunksizes is not None or contiguous:
*/
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3164; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3174, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v_msg);
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3164; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3174, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3164; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3174, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3161
+ /* "netCDF4/_netCDF4.pyx":3171
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* for n from 0 <= n < ndims:
* if not dims[n].isunlimited() and \ # <<<<<<<<<<<<<<
@@ -28405,23 +28341,23 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3165
+ /* "netCDF4/_netCDF4.pyx":3175
* msg = 'chunksize cannot exceed dimension size'
* raise ValueError(msg)
* chunksizesp[n] = chunksizes[n] # <<<<<<<<<<<<<<
* if chunksizes is not None or contiguous:
* ierr = nc_def_var_chunking(self._grpid, self._varid, icontiguous, chunksizesp)
*/
- __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_chunksizes, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3165; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_chunksizes, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3175, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3165; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_14 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3175, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
(__pyx_v_chunksizesp[__pyx_v_n]) = __pyx_t_14;
}
}
__pyx_L70:;
- /* "netCDF4/_netCDF4.pyx":3166
+ /* "netCDF4/_netCDF4.pyx":3176
* raise ValueError(msg)
* chunksizesp[n] = chunksizes[n]
* if chunksizes is not None or contiguous: # <<<<<<<<<<<<<<
@@ -28435,12 +28371,12 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = __pyx_t_8;
goto __pyx_L79_bool_binop_done;
}
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_contiguous); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3166; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_contiguous); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3176, __pyx_L1_error)
__pyx_t_2 = __pyx_t_8;
__pyx_L79_bool_binop_done:;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3167
+ /* "netCDF4/_netCDF4.pyx":3177
* chunksizesp[n] = chunksizes[n]
* if chunksizes is not None or contiguous:
* ierr = nc_def_var_chunking(self._grpid, self._varid, icontiguous, chunksizesp) # <<<<<<<<<<<<<<
@@ -28449,7 +28385,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = nc_def_var_chunking(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_icontiguous, __pyx_v_chunksizesp);
- /* "netCDF4/_netCDF4.pyx":3168
+ /* "netCDF4/_netCDF4.pyx":3178
* if chunksizes is not None or contiguous:
* ierr = nc_def_var_chunking(self._grpid, self._varid, icontiguous, chunksizesp)
* free(chunksizesp) # <<<<<<<<<<<<<<
@@ -28458,7 +28394,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
free(__pyx_v_chunksizesp);
- /* "netCDF4/_netCDF4.pyx":3169
+ /* "netCDF4/_netCDF4.pyx":3179
* ierr = nc_def_var_chunking(self._grpid, self._varid, icontiguous, chunksizesp)
* free(chunksizesp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -28468,19 +28404,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3170
+ /* "netCDF4/_netCDF4.pyx":3180
* free(chunksizesp)
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set endian-ness of variable
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3170; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3180, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3170; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3180, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_2) {
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3170; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3180, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -28493,17 +28429,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_3) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3170; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3180, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3170; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3180, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3171
+ /* "netCDF4/_netCDF4.pyx":3181
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -28511,22 +28447,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* if endian == 'little':
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_6 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3171; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3171; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3171; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3171; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3181, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3169
+ /* "netCDF4/_netCDF4.pyx":3179
* ierr = nc_def_var_chunking(self._grpid, self._varid, icontiguous, chunksizesp)
* free(chunksizesp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -28535,7 +28471,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3166
+ /* "netCDF4/_netCDF4.pyx":3176
* raise ValueError(msg)
* chunksizesp[n] = chunksizes[n]
* if chunksizes is not None or contiguous: # <<<<<<<<<<<<<<
@@ -28544,7 +28480,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3146
+ /* "netCDF4/_netCDF4.pyx":3156
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set chunking stuff.
* if ndims: # don't bother for scalar variable. # <<<<<<<<<<<<<<
@@ -28553,17 +28489,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3173
+ /* "netCDF4/_netCDF4.pyx":3183
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set endian-ness of variable
* if endian == 'little': # <<<<<<<<<<<<<<
* ierr = nc_def_var_endian(self._grpid, self._varid, NC_ENDIAN_LITTLE)
* elif endian == 'big':
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_endian, __pyx_n_s_little, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3173; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_endian, __pyx_n_s_little, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3183, __pyx_L1_error)
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3174
+ /* "netCDF4/_netCDF4.pyx":3184
* # set endian-ness of variable
* if endian == 'little':
* ierr = nc_def_var_endian(self._grpid, self._varid, NC_ENDIAN_LITTLE) # <<<<<<<<<<<<<<
@@ -28572,7 +28508,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = nc_def_var_endian(__pyx_v_self->_grpid, __pyx_v_self->_varid, NC_ENDIAN_LITTLE);
- /* "netCDF4/_netCDF4.pyx":3173
+ /* "netCDF4/_netCDF4.pyx":3183
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # set endian-ness of variable
* if endian == 'little': # <<<<<<<<<<<<<<
@@ -28582,17 +28518,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L83;
}
- /* "netCDF4/_netCDF4.pyx":3175
+ /* "netCDF4/_netCDF4.pyx":3185
* if endian == 'little':
* ierr = nc_def_var_endian(self._grpid, self._varid, NC_ENDIAN_LITTLE)
* elif endian == 'big': # <<<<<<<<<<<<<<
* ierr = nc_def_var_endian(self._grpid, self._varid, NC_ENDIAN_BIG)
* elif endian == 'native':
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_endian, __pyx_n_s_big, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3175; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_endian, __pyx_n_s_big, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3185, __pyx_L1_error)
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3176
+ /* "netCDF4/_netCDF4.pyx":3186
* ierr = nc_def_var_endian(self._grpid, self._varid, NC_ENDIAN_LITTLE)
* elif endian == 'big':
* ierr = nc_def_var_endian(self._grpid, self._varid, NC_ENDIAN_BIG) # <<<<<<<<<<<<<<
@@ -28601,7 +28537,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = nc_def_var_endian(__pyx_v_self->_grpid, __pyx_v_self->_varid, NC_ENDIAN_BIG);
- /* "netCDF4/_netCDF4.pyx":3175
+ /* "netCDF4/_netCDF4.pyx":3185
* if endian == 'little':
* ierr = nc_def_var_endian(self._grpid, self._varid, NC_ENDIAN_LITTLE)
* elif endian == 'big': # <<<<<<<<<<<<<<
@@ -28611,19 +28547,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L83;
}
- /* "netCDF4/_netCDF4.pyx":3177
+ /* "netCDF4/_netCDF4.pyx":3187
* elif endian == 'big':
* ierr = nc_def_var_endian(self._grpid, self._varid, NC_ENDIAN_BIG)
* elif endian == 'native': # <<<<<<<<<<<<<<
* pass # this is the default format.
* else:
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_endian, __pyx_n_s_native, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3177; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_endian, __pyx_n_s_native, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3187, __pyx_L1_error)
if (__pyx_t_2) {
goto __pyx_L83;
}
- /* "netCDF4/_netCDF4.pyx":3180
+ /* "netCDF4/_netCDF4.pyx":3190
* pass # this is the default format.
* else:
* raise ValueError("'endian' keyword argument must be 'little','big' or 'native', got '%s'" % endian) # <<<<<<<<<<<<<<
@@ -28631,23 +28567,23 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* if grp.data_model != 'NETCDF4': grp._enddef()
*/
/*else*/ {
- __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_endian_keyword_argument_must_be, __pyx_v_endian); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3180; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_endian_keyword_argument_must_be, __pyx_v_endian); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3190, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3180; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3190, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3180; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3190, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3180; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3190, __pyx_L1_error)
}
__pyx_L83:;
- /* "netCDF4/_netCDF4.pyx":3181
+ /* "netCDF4/_netCDF4.pyx":3191
* else:
* raise ValueError("'endian' keyword argument must be 'little','big' or 'native', got '%s'" % endian)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -28657,19 +28593,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3182
+ /* "netCDF4/_netCDF4.pyx":3192
* raise ValueError("'endian' keyword argument must be 'little','big' or 'native', got '%s'" % endian)
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* else:
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3182; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3192, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3182; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3192, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_2) {
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3182; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3192, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -28682,17 +28618,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_3) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3182; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3192, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3182; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3192, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3183
+ /* "netCDF4/_netCDF4.pyx":3193
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -28700,22 +28636,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* if endian != 'native':
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_6 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3183; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3193, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3183; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3193, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3183; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3193, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3183; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3193, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3181
+ /* "netCDF4/_netCDF4.pyx":3191
* else:
* raise ValueError("'endian' keyword argument must be 'little','big' or 'native', got '%s'" % endian)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -28724,7 +28660,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3128
+ /* "netCDF4/_netCDF4.pyx":3138
* # and fletcher32 are silently ignored. Only
* # endian='native' allowed for NETCDF3.
* if grp.data_model in ['NETCDF4','NETCDF4_CLASSIC']: # <<<<<<<<<<<<<<
@@ -28734,7 +28670,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L53;
}
- /* "netCDF4/_netCDF4.pyx":3185
+ /* "netCDF4/_netCDF4.pyx":3195
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* else:
* if endian != 'native': # <<<<<<<<<<<<<<
@@ -28742,10 +28678,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* raise RuntimeError(msg)
*/
/*else*/ {
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_endian, __pyx_n_s_native, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3185; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_endian, __pyx_n_s_native, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3195, __pyx_L1_error)
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3186
+ /* "netCDF4/_netCDF4.pyx":3196
* else:
* if endian != 'native':
* msg="only endian='native' allowed for NETCDF3 files" # <<<<<<<<<<<<<<
@@ -28755,26 +28691,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(__pyx_kp_s_only_endian_native_allowed_for_N);
__Pyx_XDECREF_SET(__pyx_v_msg, __pyx_kp_s_only_endian_native_allowed_for_N);
- /* "netCDF4/_netCDF4.pyx":3187
+ /* "netCDF4/_netCDF4.pyx":3197
* if endian != 'native':
* msg="only endian='native' allowed for NETCDF3 files"
* raise RuntimeError(msg) # <<<<<<<<<<<<<<
* # set a fill value for this variable if fill_value keyword
* # given. This avoids the HDF5 overhead of deleting and
*/
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3187; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3197, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_msg);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3187; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3197, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3187; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3197, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3185
+ /* "netCDF4/_netCDF4.pyx":3195
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* else:
* if endian != 'native': # <<<<<<<<<<<<<<
@@ -28785,7 +28721,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L53:;
- /* "netCDF4/_netCDF4.pyx":3191
+ /* "netCDF4/_netCDF4.pyx":3201
* # given. This avoids the HDF5 overhead of deleting and
* # recreating the dataset if it is set later (after the enddef).
* if fill_value is not None: # <<<<<<<<<<<<<<
@@ -28796,14 +28732,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = (__pyx_t_2 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3192
+ /* "netCDF4/_netCDF4.pyx":3202
* # recreating the dataset if it is set later (after the enddef).
* if fill_value is not None:
* if not fill_value and isinstance(fill_value,bool): # <<<<<<<<<<<<<<
* # no filling for this variable if fill_value==False.
* if not self._isprimitive:
*/
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_fill_value); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3192; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_fill_value); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3202, __pyx_L1_error)
__pyx_t_1 = ((!__pyx_t_2) != 0);
if (__pyx_t_1) {
} else {
@@ -28812,25 +28748,25 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_t_7 = ((PyObject*)&PyBool_Type);
__Pyx_INCREF(__pyx_t_7);
- __pyx_t_1 = PyObject_IsInstance(__pyx_v_fill_value, __pyx_t_7); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3192; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_IsInstance(__pyx_v_fill_value, __pyx_t_7); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 3202, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_2 = (__pyx_t_1 != 0);
__pyx_t_8 = __pyx_t_2;
__pyx_L89_bool_binop_done:;
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3194
+ /* "netCDF4/_netCDF4.pyx":3204
* if not fill_value and isinstance(fill_value,bool):
* # no filling for this variable if fill_value==False.
* if not self._isprimitive: # <<<<<<<<<<<<<<
* # no fill values for VLEN and compound variables
* # anyway.
*/
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3194; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3204, __pyx_L1_error)
__pyx_t_2 = ((!__pyx_t_8) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3197
+ /* "netCDF4/_netCDF4.pyx":3207
* # no fill values for VLEN and compound variables
* # anyway.
* ierr = 0 # <<<<<<<<<<<<<<
@@ -28839,7 +28775,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_ierr = 0;
- /* "netCDF4/_netCDF4.pyx":3194
+ /* "netCDF4/_netCDF4.pyx":3204
* if not fill_value and isinstance(fill_value,bool):
* # no filling for this variable if fill_value==False.
* if not self._isprimitive: # <<<<<<<<<<<<<<
@@ -28849,7 +28785,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L91;
}
- /* "netCDF4/_netCDF4.pyx":3199
+ /* "netCDF4/_netCDF4.pyx":3209
* ierr = 0
* else:
* ierr = nc_def_var_fill(self._grpid, self._varid, 1, NULL) # <<<<<<<<<<<<<<
@@ -28861,7 +28797,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L91:;
- /* "netCDF4/_netCDF4.pyx":3200
+ /* "netCDF4/_netCDF4.pyx":3210
* else:
* ierr = nc_def_var_fill(self._grpid, self._varid, 1, NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -28871,19 +28807,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_2 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3201
+ /* "netCDF4/_netCDF4.pyx":3211
* ierr = nc_def_var_fill(self._grpid, self._varid, 1, NULL)
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* else:
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3201; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3201; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3211, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_2) {
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3201; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -28896,17 +28832,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_3) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3201; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3211, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3201; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3211, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3202
+ /* "netCDF4/_netCDF4.pyx":3212
* if ierr != NC_NOERR:
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -28914,22 +28850,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* # cast fill_value to type of variable.
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3212, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3212, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3212, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3212, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3200
+ /* "netCDF4/_netCDF4.pyx":3210
* else:
* ierr = nc_def_var_fill(self._grpid, self._varid, 1, NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -28938,7 +28874,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3192
+ /* "netCDF4/_netCDF4.pyx":3202
* # recreating the dataset if it is set later (after the enddef).
* if fill_value is not None:
* if not fill_value and isinstance(fill_value,bool): # <<<<<<<<<<<<<<
@@ -28948,7 +28884,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L88;
}
- /* "netCDF4/_netCDF4.pyx":3205
+ /* "netCDF4/_netCDF4.pyx":3215
* else:
* # cast fill_value to type of variable.
* if self._isprimitive or self._isenum: # <<<<<<<<<<<<<<
@@ -28956,27 +28892,27 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* _set_att(self._grp, self._varid, '_FillValue',\
*/
/*else*/ {
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3215, __pyx_L1_error)
if (!__pyx_t_8) {
} else {
__pyx_t_2 = __pyx_t_8;
goto __pyx_L95_bool_binop_done;
}
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3205; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3215, __pyx_L1_error)
__pyx_t_2 = __pyx_t_8;
__pyx_L95_bool_binop_done:;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3206
+ /* "netCDF4/_netCDF4.pyx":3216
* # cast fill_value to type of variable.
* if self._isprimitive or self._isenum:
* fillval = numpy.array(fill_value, self.dtype) # <<<<<<<<<<<<<<
* _set_att(self._grp, self._varid, '_FillValue',\
* fillval, xtype=xtype)
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3206; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3216, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3206; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3216, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -28991,7 +28927,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_15 = 1;
}
}
- __pyx_t_5 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3206; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(2+__pyx_t_15); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3216, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL;
@@ -29002,14 +28938,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_15, __pyx_v_self->dtype);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3206; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3216, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_fillval = __pyx_t_7;
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3207
+ /* "netCDF4/_netCDF4.pyx":3217
* if self._isprimitive or self._isenum:
* fillval = numpy.array(fill_value, self.dtype)
* _set_att(self._grp, self._varid, '_FillValue',\ # <<<<<<<<<<<<<<
@@ -29019,7 +28955,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_7 = __pyx_v_self->_grp;
__Pyx_INCREF(__pyx_t_7);
- /* "netCDF4/_netCDF4.pyx":3208
+ /* "netCDF4/_netCDF4.pyx":3218
* fillval = numpy.array(fill_value, self.dtype)
* _set_att(self._grp, self._varid, '_FillValue',\
* fillval, xtype=xtype) # <<<<<<<<<<<<<<
@@ -29028,12 +28964,12 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_t_16.__pyx_n = 1;
__pyx_t_16.xtype = __pyx_v_xtype;
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__set_att(__pyx_t_7, __pyx_v_self->_varid, __pyx_n_s_FillValue, __pyx_v_fillval, &__pyx_t_16); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3207; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__set_att(__pyx_t_7, __pyx_v_self->_varid, __pyx_n_s_FillValue, __pyx_v_fillval, &__pyx_t_16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3217, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3205
+ /* "netCDF4/_netCDF4.pyx":3215
* else:
* # cast fill_value to type of variable.
* if self._isprimitive or self._isenum: # <<<<<<<<<<<<<<
@@ -29043,7 +28979,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
goto __pyx_L94;
}
- /* "netCDF4/_netCDF4.pyx":3210
+ /* "netCDF4/_netCDF4.pyx":3220
* fillval, xtype=xtype)
* else:
* raise AttributeError("cannot set _FillValue attribute for VLEN or compound variable") # <<<<<<<<<<<<<<
@@ -29051,17 +28987,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* self.least_significant_digit = least_significant_digit
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3220, __pyx_L1_error)
}
__pyx_L94:;
}
__pyx_L88:;
- /* "netCDF4/_netCDF4.pyx":3191
+ /* "netCDF4/_netCDF4.pyx":3201
* # given. This avoids the HDF5 overhead of deleting and
* # recreating the dataset if it is set later (after the enddef).
* if fill_value is not None: # <<<<<<<<<<<<<<
@@ -29070,7 +29006,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3211
+ /* "netCDF4/_netCDF4.pyx":3221
* else:
* raise AttributeError("cannot set _FillValue attribute for VLEN or compound variable")
* if least_significant_digit is not None: # <<<<<<<<<<<<<<
@@ -29081,16 +29017,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = (__pyx_t_2 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3212
+ /* "netCDF4/_netCDF4.pyx":3222
* raise AttributeError("cannot set _FillValue attribute for VLEN or compound variable")
* if least_significant_digit is not None:
* self.least_significant_digit = least_significant_digit # <<<<<<<<<<<<<<
* # leave define mode if not a NETCDF4 format file.
* if grp.data_model != 'NETCDF4': grp._enddef()
*/
- if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_least_significant_digit, __pyx_v_least_significant_digit) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3212; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_least_significant_digit, __pyx_v_least_significant_digit) < 0) __PYX_ERR(0, 3222, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3211
+ /* "netCDF4/_netCDF4.pyx":3221
* else:
* raise AttributeError("cannot set _FillValue attribute for VLEN or compound variable")
* if least_significant_digit is not None: # <<<<<<<<<<<<<<
@@ -29099,19 +29035,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3214
+ /* "netCDF4/_netCDF4.pyx":3224
* self.least_significant_digit = least_significant_digit
* # leave define mode if not a NETCDF4 format file.
* if grp.data_model != 'NETCDF4': grp._enddef() # <<<<<<<<<<<<<<
* # count how many unlimited dimensions there are.
* self._nunlimdim = 0
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3224, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3224, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_8) {
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3224, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -29124,10 +29060,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_5) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3224, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3224, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -29136,7 +29072,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__pyx_L39:;
- /* "netCDF4/_netCDF4.pyx":3216
+ /* "netCDF4/_netCDF4.pyx":3226
* if grp.data_model != 'NETCDF4': grp._enddef()
* # count how many unlimited dimensions there are.
* self._nunlimdim = 0 # <<<<<<<<<<<<<<
@@ -29145,7 +29081,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
__pyx_v_self->_nunlimdim = 0;
- /* "netCDF4/_netCDF4.pyx":3217
+ /* "netCDF4/_netCDF4.pyx":3227
* # count how many unlimited dimensions there are.
* self._nunlimdim = 0
* for dimname in dimensions: # <<<<<<<<<<<<<<
@@ -29156,26 +29092,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_3 = __pyx_v_dimensions; __Pyx_INCREF(__pyx_t_3); __pyx_t_15 = 0;
__pyx_t_17 = NULL;
} else {
- __pyx_t_15 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_dimensions); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_dimensions); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_17 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_17 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 3227, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_17)) {
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_15 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_15); __Pyx_INCREF(__pyx_t_7); __pyx_t_15++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_15); __Pyx_INCREF(__pyx_t_7); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 3227, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_3, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_3, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_15 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_15); __Pyx_INCREF(__pyx_t_7); __pyx_t_15++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_15); __Pyx_INCREF(__pyx_t_7); __pyx_t_15++; if (unlikely(0 < 0)) __PYX_ERR(0, 3227, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_3, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_3, __pyx_t_15); __pyx_t_15++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -29185,7 +29121,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3227, __pyx_L1_error)
}
break;
}
@@ -29194,14 +29130,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3219
+ /* "netCDF4/_netCDF4.pyx":3229
* for dimname in dimensions:
* # look in current group, and parents for dim.
* dim = _find_dim(self._grp, dimname) # <<<<<<<<<<<<<<
* if dim.isunlimited(): self._nunlimdim = self._nunlimdim + 1
* # set ndim attribute (number of dimensions).
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3229, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
__pyx_t_11 = 0;
@@ -29215,7 +29151,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_11 = 1;
}
}
- __pyx_t_18 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 3229, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_18);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_6); __pyx_t_6 = NULL;
@@ -29226,21 +29162,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_11, __pyx_v_dimname);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_18, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_18, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3229, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF_SET(__pyx_v_dim, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3220
+ /* "netCDF4/_netCDF4.pyx":3230
* # look in current group, and parents for dim.
* dim = _find_dim(self._grp, dimname)
* if dim.isunlimited(): self._nunlimdim = self._nunlimdim + 1 # <<<<<<<<<<<<<<
* # set ndim attribute (number of dimensions).
* with nogil:
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3230, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_18 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -29253,20 +29189,20 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_18) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_18); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_18); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3230, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3230, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3230, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_8) {
__pyx_v_self->_nunlimdim = (__pyx_v_self->_nunlimdim + 1);
}
- /* "netCDF4/_netCDF4.pyx":3217
+ /* "netCDF4/_netCDF4.pyx":3227
* # count how many unlimited dimensions there are.
* self._nunlimdim = 0
* for dimname in dimensions: # <<<<<<<<<<<<<<
@@ -29276,7 +29212,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3222
+ /* "netCDF4/_netCDF4.pyx":3232
* if dim.isunlimited(): self._nunlimdim = self._nunlimdim + 1
* # set ndim attribute (number of dimensions).
* with nogil: # <<<<<<<<<<<<<<
@@ -29290,7 +29226,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3223
+ /* "netCDF4/_netCDF4.pyx":3233
* # set ndim attribute (number of dimensions).
* with nogil:
* ierr = nc_inq_varndims(self._grpid, self._varid, &numdims) # <<<<<<<<<<<<<<
@@ -29300,7 +29236,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_v_ierr = nc_inq_varndims(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_numdims));
}
- /* "netCDF4/_netCDF4.pyx":3222
+ /* "netCDF4/_netCDF4.pyx":3232
* if dim.isunlimited(): self._nunlimdim = self._nunlimdim + 1
* # set ndim attribute (number of dimensions).
* with nogil: # <<<<<<<<<<<<<<
@@ -29318,7 +29254,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
- /* "netCDF4/_netCDF4.pyx":3224
+ /* "netCDF4/_netCDF4.pyx":3234
* with nogil:
* ierr = nc_inq_varndims(self._grpid, self._varid, &numdims)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -29328,7 +29264,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_t_8 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3225
+ /* "netCDF4/_netCDF4.pyx":3235
* ierr = nc_inq_varndims(self._grpid, self._varid, &numdims)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -29336,22 +29272,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
* self._name = name
*/
__pyx_t_10 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_10, 0, strlen(__pyx_t_10), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3235, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3235, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3235, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3235, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3224
+ /* "netCDF4/_netCDF4.pyx":3234
* with nogil:
* ierr = nc_inq_varndims(self._grpid, self._varid, &numdims)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -29360,14 +29296,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":3226
+ /* "netCDF4/_netCDF4.pyx":3236
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* self.ndim = numdims # <<<<<<<<<<<<<<
* self._name = name
* # default for automatically applying scale_factor and
*/
- __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_numdims); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3226; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_numdims); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3236, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_v_self->ndim);
@@ -29375,7 +29311,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__pyx_v_self->ndim = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3227
+ /* "netCDF4/_netCDF4.pyx":3237
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* self.ndim = numdims
* self._name = name # <<<<<<<<<<<<<<
@@ -29388,7 +29324,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_name);
__pyx_v_self->_name = __pyx_v_name;
- /* "netCDF4/_netCDF4.pyx":3230
+ /* "netCDF4/_netCDF4.pyx":3240
* # default for automatically applying scale_factor and
* # add_offset, and converting to/from masked arrays is True.
* self.scale = True # <<<<<<<<<<<<<<
@@ -29401,7 +29337,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->scale);
__pyx_v_self->scale = Py_True;
- /* "netCDF4/_netCDF4.pyx":3231
+ /* "netCDF4/_netCDF4.pyx":3241
* # add_offset, and converting to/from masked arrays is True.
* self.scale = True
* self.mask = True # <<<<<<<<<<<<<<
@@ -29414,14 +29350,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->mask);
__pyx_v_self->mask = Py_True;
- /* "netCDF4/_netCDF4.pyx":3232
+ /* "netCDF4/_netCDF4.pyx":3242
* self.scale = True
* self.mask = True
* if 'least_significant_digit' in self.ncattrs(): # <<<<<<<<<<<<<<
* self._has_lsd = True
*
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3242, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -29434,19 +29370,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
}
}
if (__pyx_t_5) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3242, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3242, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_least_significant_digit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_n_s_least_significant_digit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3242, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = (__pyx_t_8 != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3233
+ /* "netCDF4/_netCDF4.pyx":3243
* self.mask = True
* if 'least_significant_digit' in self.ncattrs():
* self._has_lsd = True # <<<<<<<<<<<<<<
@@ -29459,7 +29395,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_v_self->_has_lsd);
__pyx_v_self->_has_lsd = Py_True;
- /* "netCDF4/_netCDF4.pyx":3232
+ /* "netCDF4/_netCDF4.pyx":3242
* self.scale = True
* self.mask = True
* if 'least_significant_digit' in self.ncattrs(): # <<<<<<<<<<<<<<
@@ -29468,7 +29404,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
*/
}
- /* "netCDF4/_netCDF4.pyx":2890
+ /* "netCDF4/_netCDF4.pyx":2900
* """The number of stored elements."""
*
* def __init__(self, grp, name, datatype, dimensions=(), zlib=False, # <<<<<<<<<<<<<<
@@ -29503,7 +29439,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable___init__(struct __pyx_obj_7netC
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3235
+/* "netCDF4/_netCDF4.pyx":3245
* self._has_lsd = True
*
* def __array__(self): # <<<<<<<<<<<<<<
@@ -29528,12 +29464,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_2__array__(struct __pyx_o
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__array__", 0);
- /* "netCDF4/_netCDF4.pyx":3239
+ /* "netCDF4/_netCDF4.pyx":3249
* # allows numpy ufuncs to work faster on Variable objects
* # (issue 216).
* return self[...] # <<<<<<<<<<<<<<
@@ -29541,13 +29474,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_2__array__(struct __pyx_o
* def __repr__(self):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_self), Py_Ellipsis); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3239; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_self), Py_Ellipsis); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3235
+ /* "netCDF4/_netCDF4.pyx":3245
* self._has_lsd = True
*
* def __array__(self): # <<<<<<<<<<<<<<
@@ -29566,7 +29499,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_2__array__(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3241
+/* "netCDF4/_netCDF4.pyx":3251
* return self[...]
*
* def __repr__(self): # <<<<<<<<<<<<<<
@@ -29596,25 +29529,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
- /* "netCDF4/_netCDF4.pyx":3242
+ /* "netCDF4/_netCDF4.pyx":3252
*
* def __repr__(self):
* if python3: # <<<<<<<<<<<<<<
* return self.__unicode__()
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3242; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3252, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3242; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3252, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3243
+ /* "netCDF4/_netCDF4.pyx":3253
* def __repr__(self):
* if python3:
* return self.__unicode__() # <<<<<<<<<<<<<<
@@ -29622,7 +29552,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
* return unicode(self).encode(default_encoding)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -29635,10 +29565,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3253, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3253, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -29646,7 +29576,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3242
+ /* "netCDF4/_netCDF4.pyx":3252
*
* def __repr__(self):
* if python3: # <<<<<<<<<<<<<<
@@ -29655,7 +29585,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3245
+ /* "netCDF4/_netCDF4.pyx":3255
* return self.__unicode__()
* else:
* return unicode(self).encode(default_encoding) # <<<<<<<<<<<<<<
@@ -29664,18 +29594,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3255, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3255, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3255, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3255, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -29688,17 +29618,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3255, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3255, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3255, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -29708,7 +29638,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":3241
+ /* "netCDF4/_netCDF4.pyx":3251
* return self[...]
*
* def __repr__(self): # <<<<<<<<<<<<<<
@@ -29731,7 +29661,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4__repr__(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3247
+/* "netCDF4/_netCDF4.pyx":3257
* return unicode(self).encode(default_encoding)
*
* def __unicode__(self): # <<<<<<<<<<<<<<
@@ -29783,12 +29713,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
int __pyx_t_17;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__unicode__", 0);
- /* "netCDF4/_netCDF4.pyx":3249
+ /* "netCDF4/_netCDF4.pyx":3259
* def __unicode__(self):
* cdef int ierr, no_fill
* if not dir(self._grp): # <<<<<<<<<<<<<<
@@ -29797,15 +29724,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
*/
__pyx_t_1 = __pyx_v_self->_grp;
__Pyx_INCREF(__pyx_t_1);
- __pyx_t_2 = PyObject_Dir(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3249; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_Dir(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3259, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3249; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3259, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = ((!__pyx_t_3) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3250
+ /* "netCDF4/_netCDF4.pyx":3260
* cdef int ierr, no_fill
* if not dir(self._grp):
* return 'Variable object no longer valid' # <<<<<<<<<<<<<<
@@ -29817,7 +29744,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__pyx_r = __pyx_kp_s_Variable_object_no_longer_valid;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3249
+ /* "netCDF4/_netCDF4.pyx":3259
* def __unicode__(self):
* cdef int ierr, no_fill
* if not dir(self._grp): # <<<<<<<<<<<<<<
@@ -29826,16 +29753,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":3251
+ /* "netCDF4/_netCDF4.pyx":3261
* if not dir(self._grp):
* return 'Variable object no longer valid'
* ncdump_var = ['%r\n' % type(self)] # <<<<<<<<<<<<<<
* dimnames = tuple([_tostr(dimname) for dimname in self.dimensions])
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\
*/
- __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_r_3, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_r_3, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3261, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3261, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2);
PyList_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
@@ -29843,24 +29770,24 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__pyx_v_ncdump_var = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3252
+ /* "netCDF4/_netCDF4.pyx":3262
* return 'Variable object no longer valid'
* ncdump_var = ['%r\n' % type(self)]
* dimnames = tuple([_tostr(dimname) for dimname in self.dimensions]) # <<<<<<<<<<<<<<
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\
* self.ncattrs()]
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
__pyx_t_5 = __pyx_t_2; __Pyx_INCREF(__pyx_t_5); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3262, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -29868,17 +29795,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
if (likely(PyList_CheckExact(__pyx_t_5))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3262, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3262, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -29888,7 +29815,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3262, __pyx_L1_error)
}
break;
}
@@ -29896,7 +29823,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
}
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_tostr); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_9 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_8))) {
@@ -29909,48 +29836,48 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
}
}
if (!__pyx_t_9) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_dimname); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_dimname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL;
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_dimname);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_dimnames = ((PyObject*)__pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3253
+ /* "netCDF4/_netCDF4.pyx":3263
* ncdump_var = ['%r\n' % type(self)]
* dimnames = tuple([_tostr(dimname) for dimname in self.dimensions])
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\ # <<<<<<<<<<<<<<
* self.ncattrs()]
* if self._iscompound:
*/
- __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- /* "netCDF4/_netCDF4.pyx":3254
+ /* "netCDF4/_netCDF4.pyx":3264
* dimnames = tuple([_tostr(dimname) for dimname in self.dimensions])
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\
* self.ncattrs()] # <<<<<<<<<<<<<<
* if self._iscompound:
* ncdump_var.append('%s %s(%s)\n' %\
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3264, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_8 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -29963,10 +29890,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
}
}
if (__pyx_t_8) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3264, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3264, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -29974,9 +29901,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3264, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3264, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -29984,17 +29911,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3264, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3264, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3264, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3264, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -30004,7 +29931,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3264, __pyx_L1_error)
}
break;
}
@@ -30013,14 +29940,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3253
+ /* "netCDF4/_netCDF4.pyx":3263
* ncdump_var = ['%r\n' % type(self)]
* dimnames = tuple([_tostr(dimname) for dimname in self.dimensions])
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\ # <<<<<<<<<<<<<<
* self.ncattrs()]
* if self._iscompound:
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getncattr); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getncattr); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_10 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_8))) {
@@ -30033,21 +29960,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
}
}
if (!__pyx_t_10) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL;
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_name);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
@@ -30055,36 +29982,36 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_1))) __PYX_ERR(0, 3263, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_attrs = ((PyObject*)__pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3255
+ /* "netCDF4/_netCDF4.pyx":3265
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\
* self.ncattrs()]
* if self._iscompound: # <<<<<<<<<<<<<<
* ncdump_var.append('%s %s(%s)\n' %\
* ('compound',self._name,', '.join(dimnames)))
*/
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3255; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3265, __pyx_L1_error)
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3257
+ /* "netCDF4/_netCDF4.pyx":3267
* if self._iscompound:
* ncdump_var.append('%s %s(%s)\n' %\
* ('compound',self._name,', '.join(dimnames))) # <<<<<<<<<<<<<<
* elif self._isvlen:
* ncdump_var.append('%s %s(%s)\n' %\
*/
- __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_compound);
__Pyx_GIVEREF(__pyx_n_s_compound);
@@ -30096,20 +30023,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3256
+ /* "netCDF4/_netCDF4.pyx":3266
* self.ncattrs()]
* if self._iscompound:
* ncdump_var.append('%s %s(%s)\n' %\ # <<<<<<<<<<<<<<
* ('compound',self._name,', '.join(dimnames)))
* elif self._isvlen:
*/
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3266, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3255
+ /* "netCDF4/_netCDF4.pyx":3265
* attrs = [' %s: %s\n' % (name,self.getncattr(name)) for name in\
* self.ncattrs()]
* if self._iscompound: # <<<<<<<<<<<<<<
@@ -30119,26 +30046,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
goto __pyx_L8;
}
- /* "netCDF4/_netCDF4.pyx":3258
+ /* "netCDF4/_netCDF4.pyx":3268
* ncdump_var.append('%s %s(%s)\n' %\
* ('compound',self._name,', '.join(dimnames)))
* elif self._isvlen: # <<<<<<<<<<<<<<
* ncdump_var.append('%s %s(%s)\n' %\
* ('vlen',self._name,', '.join(dimnames)))
*/
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3258; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3268, __pyx_L1_error)
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3260
+ /* "netCDF4/_netCDF4.pyx":3270
* elif self._isvlen:
* ncdump_var.append('%s %s(%s)\n' %\
* ('vlen',self._name,', '.join(dimnames))) # <<<<<<<<<<<<<<
* elif self._isenum:
* ncdump_var.append('%s %s(%s)\n' %\
*/
- __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3260; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3270, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3260; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3270, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_vlen);
__Pyx_GIVEREF(__pyx_n_s_vlen);
@@ -30150,20 +30077,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3259
+ /* "netCDF4/_netCDF4.pyx":3269
* ('compound',self._name,', '.join(dimnames)))
* elif self._isvlen:
* ncdump_var.append('%s %s(%s)\n' %\ # <<<<<<<<<<<<<<
* ('vlen',self._name,', '.join(dimnames)))
* elif self._isenum:
*/
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3269, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3269, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3258
+ /* "netCDF4/_netCDF4.pyx":3268
* ncdump_var.append('%s %s(%s)\n' %\
* ('compound',self._name,', '.join(dimnames)))
* elif self._isvlen: # <<<<<<<<<<<<<<
@@ -30173,26 +30100,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
goto __pyx_L8;
}
- /* "netCDF4/_netCDF4.pyx":3261
+ /* "netCDF4/_netCDF4.pyx":3271
* ncdump_var.append('%s %s(%s)\n' %\
* ('vlen',self._name,', '.join(dimnames)))
* elif self._isenum: # <<<<<<<<<<<<<<
* ncdump_var.append('%s %s(%s)\n' %\
* ('enum',self._name,', '.join(dimnames)))
*/
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3271, __pyx_L1_error)
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3263
+ /* "netCDF4/_netCDF4.pyx":3273
* elif self._isenum:
* ncdump_var.append('%s %s(%s)\n' %\
* ('enum',self._name,', '.join(dimnames))) # <<<<<<<<<<<<<<
* else:
* ncdump_var.append('%s %s(%s)\n' %\
*/
- __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3273, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3273, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_enum);
__Pyx_GIVEREF(__pyx_n_s_enum);
@@ -30204,20 +30131,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3262
+ /* "netCDF4/_netCDF4.pyx":3272
* ('vlen',self._name,', '.join(dimnames)))
* elif self._isenum:
* ncdump_var.append('%s %s(%s)\n' %\ # <<<<<<<<<<<<<<
* ('enum',self._name,', '.join(dimnames)))
* else:
*/
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3262; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3272, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3261
+ /* "netCDF4/_netCDF4.pyx":3271
* ncdump_var.append('%s %s(%s)\n' %\
* ('vlen',self._name,', '.join(dimnames)))
* elif self._isenum: # <<<<<<<<<<<<<<
@@ -30227,7 +30154,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
goto __pyx_L8;
}
- /* "netCDF4/_netCDF4.pyx":3265
+ /* "netCDF4/_netCDF4.pyx":3275
* ('enum',self._name,', '.join(dimnames)))
* else:
* ncdump_var.append('%s %s(%s)\n' %\ # <<<<<<<<<<<<<<
@@ -30236,16 +30163,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
*/
/*else*/ {
- /* "netCDF4/_netCDF4.pyx":3266
+ /* "netCDF4/_netCDF4.pyx":3276
* else:
* ncdump_var.append('%s %s(%s)\n' %\
* (self.dtype,self._name,', '.join(dimnames))) # <<<<<<<<<<<<<<
* ncdump_var = ncdump_var + attrs
* if self._iscompound:
*/
- __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3266; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_dimnames); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3266; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
@@ -30257,56 +30184,56 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3265
+ /* "netCDF4/_netCDF4.pyx":3275
* ('enum',self._name,', '.join(dimnames)))
* else:
* ncdump_var.append('%s %s(%s)\n' %\ # <<<<<<<<<<<<<<
* (self.dtype,self._name,', '.join(dimnames)))
* ncdump_var = ncdump_var + attrs
*/
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3265; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3275, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3265; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3275, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__pyx_L8:;
- /* "netCDF4/_netCDF4.pyx":3267
+ /* "netCDF4/_netCDF4.pyx":3277
* ncdump_var.append('%s %s(%s)\n' %\
* (self.dtype,self._name,', '.join(dimnames)))
* ncdump_var = ncdump_var + attrs # <<<<<<<<<<<<<<
* if self._iscompound:
* ncdump_var.append('compound data type: %s\n' % self.dtype)
*/
- __pyx_t_5 = PyNumber_Add(__pyx_v_ncdump_var, __pyx_v_attrs); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3267; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyNumber_Add(__pyx_v_ncdump_var, __pyx_v_attrs); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3277, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF_SET(__pyx_v_ncdump_var, ((PyObject*)__pyx_t_5));
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3268
+ /* "netCDF4/_netCDF4.pyx":3278
* (self.dtype,self._name,', '.join(dimnames)))
* ncdump_var = ncdump_var + attrs
* if self._iscompound: # <<<<<<<<<<<<<<
* ncdump_var.append('compound data type: %s\n' % self.dtype)
* elif self._isvlen:
*/
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3268; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3278, __pyx_L1_error)
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3269
+ /* "netCDF4/_netCDF4.pyx":3279
* ncdump_var = ncdump_var + attrs
* if self._iscompound:
* ncdump_var.append('compound data type: %s\n' % self.dtype) # <<<<<<<<<<<<<<
* elif self._isvlen:
* ncdump_var.append('vlen data type: %s\n' % self.dtype)
*/
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_compound_data_type_s, __pyx_v_self->dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3269; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_compound_data_type_s, __pyx_v_self->dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3279, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3269; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3279, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3268
+ /* "netCDF4/_netCDF4.pyx":3278
* (self.dtype,self._name,', '.join(dimnames)))
* ncdump_var = ncdump_var + attrs
* if self._iscompound: # <<<<<<<<<<<<<<
@@ -30316,29 +30243,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":3270
+ /* "netCDF4/_netCDF4.pyx":3280
* if self._iscompound:
* ncdump_var.append('compound data type: %s\n' % self.dtype)
* elif self._isvlen: # <<<<<<<<<<<<<<
* ncdump_var.append('vlen data type: %s\n' % self.dtype)
* elif self._isenum:
*/
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3270; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3280, __pyx_L1_error)
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3271
+ /* "netCDF4/_netCDF4.pyx":3281
* ncdump_var.append('compound data type: %s\n' % self.dtype)
* elif self._isvlen:
* ncdump_var.append('vlen data type: %s\n' % self.dtype) # <<<<<<<<<<<<<<
* elif self._isenum:
* ncdump_var.append('enum data type: %s\n' % self.dtype)
*/
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_vlen_data_type_s, __pyx_v_self->dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3271; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_vlen_data_type_s, __pyx_v_self->dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3281, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3271; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3281, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3270
+ /* "netCDF4/_netCDF4.pyx":3280
* if self._iscompound:
* ncdump_var.append('compound data type: %s\n' % self.dtype)
* elif self._isvlen: # <<<<<<<<<<<<<<
@@ -30348,29 +30275,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":3272
+ /* "netCDF4/_netCDF4.pyx":3282
* elif self._isvlen:
* ncdump_var.append('vlen data type: %s\n' % self.dtype)
* elif self._isenum: # <<<<<<<<<<<<<<
* ncdump_var.append('enum data type: %s\n' % self.dtype)
* unlimdims = []
*/
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3272; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3282, __pyx_L1_error)
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3273
+ /* "netCDF4/_netCDF4.pyx":3283
* ncdump_var.append('vlen data type: %s\n' % self.dtype)
* elif self._isenum:
* ncdump_var.append('enum data type: %s\n' % self.dtype) # <<<<<<<<<<<<<<
* unlimdims = []
* for dimname in self.dimensions:
*/
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_enum_data_type_s, __pyx_v_self->dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3273; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_enum_data_type_s, __pyx_v_self->dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3283, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3273; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3283, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3272
+ /* "netCDF4/_netCDF4.pyx":3282
* elif self._isvlen:
* ncdump_var.append('vlen data type: %s\n' % self.dtype)
* elif self._isenum: # <<<<<<<<<<<<<<
@@ -30380,34 +30307,34 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
}
__pyx_L9:;
- /* "netCDF4/_netCDF4.pyx":3274
+ /* "netCDF4/_netCDF4.pyx":3284
* elif self._isenum:
* ncdump_var.append('enum data type: %s\n' % self.dtype)
* unlimdims = [] # <<<<<<<<<<<<<<
* for dimname in self.dimensions:
* dim = _find_dim(self._grp, dimname)
*/
- __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3284, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_v_unlimdims = ((PyObject*)__pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3275
+ /* "netCDF4/_netCDF4.pyx":3285
* ncdump_var.append('enum data type: %s\n' % self.dtype)
* unlimdims = []
* for dimname in self.dimensions: # <<<<<<<<<<<<<<
* dim = _find_dim(self._grp, dimname)
* if dim.isunlimited():
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3285, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) {
__pyx_t_2 = __pyx_t_5; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3285, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3285, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
for (;;) {
@@ -30415,17 +30342,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3285, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3285, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3285, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3285, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
}
@@ -30435,7 +30362,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3285, __pyx_L1_error)
}
break;
}
@@ -30444,14 +30371,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3276
+ /* "netCDF4/_netCDF4.pyx":3286
* unlimdims = []
* for dimname in self.dimensions:
* dim = _find_dim(self._grp, dimname) # <<<<<<<<<<<<<<
* if dim.isunlimited():
* unlimdims.append(dimname)
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3276; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3286, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_8 = NULL;
__pyx_t_12 = 0;
@@ -30465,7 +30392,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__pyx_t_12 = 1;
}
}
- __pyx_t_9 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3276; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3286, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -30476,21 +30403,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_12, __pyx_v_dimname);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3276; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3286, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_dim, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3277
+ /* "netCDF4/_netCDF4.pyx":3287
* for dimname in self.dimensions:
* dim = _find_dim(self._grp, dimname)
* if dim.isunlimited(): # <<<<<<<<<<<<<<
* unlimdims.append(dimname)
* if (self._grp.path != '/'): ncdump_var.append('path = %s\n' % self._grp.path)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3277; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3287, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_9 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -30503,27 +30430,27 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
}
}
if (__pyx_t_9) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3277; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3287, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3277; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3287, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3277; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3287, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3278
+ /* "netCDF4/_netCDF4.pyx":3288
* dim = _find_dim(self._grp, dimname)
* if dim.isunlimited():
* unlimdims.append(dimname) # <<<<<<<<<<<<<<
* if (self._grp.path != '/'): ncdump_var.append('path = %s\n' % self._grp.path)
* ncdump_var.append('unlimited dimensions: %s\n' % ', '.join(unlimdims))
*/
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_unlimdims, __pyx_v_dimname); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3278; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_unlimdims, __pyx_v_dimname); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3288, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3277
+ /* "netCDF4/_netCDF4.pyx":3287
* for dimname in self.dimensions:
* dim = _find_dim(self._grp, dimname)
* if dim.isunlimited(): # <<<<<<<<<<<<<<
@@ -30532,7 +30459,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":3275
+ /* "netCDF4/_netCDF4.pyx":3285
* ncdump_var.append('enum data type: %s\n' % self.dtype)
* unlimdims = []
* for dimname in self.dimensions: # <<<<<<<<<<<<<<
@@ -30542,61 +30469,61 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3279
+ /* "netCDF4/_netCDF4.pyx":3289
* if dim.isunlimited():
* unlimdims.append(dimname)
* if (self._grp.path != '/'): ncdump_var.append('path = %s\n' % self._grp.path) # <<<<<<<<<<<<<<
* ncdump_var.append('unlimited dimensions: %s\n' % ', '.join(unlimdims))
* ncdump_var.append('current shape = %s\n' % repr(self.shape))
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3279; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3289, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_kp_s__16, Py_NE)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3279; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_kp_s__16, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3289, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3279; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3289, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_path_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3279; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_path_s, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3289, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3279; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_5); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3289, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3280
+ /* "netCDF4/_netCDF4.pyx":3290
* unlimdims.append(dimname)
* if (self._grp.path != '/'): ncdump_var.append('path = %s\n' % self._grp.path)
* ncdump_var.append('unlimited dimensions: %s\n' % ', '.join(unlimdims)) # <<<<<<<<<<<<<<
* ncdump_var.append('current shape = %s\n' % repr(self.shape))
* with nogil:
*/
- __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_unlimdims); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3280; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Join(__pyx_kp_s__21, __pyx_v_unlimdims); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3290, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_unlimited_dimensions_s, __pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3280; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_unlimited_dimensions_s, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3290, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_2); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3280; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_2); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3290, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3281
+ /* "netCDF4/_netCDF4.pyx":3291
* if (self._grp.path != '/'): ncdump_var.append('path = %s\n' % self._grp.path)
* ncdump_var.append('unlimited dimensions: %s\n' % ', '.join(unlimdims))
* ncdump_var.append('current shape = %s\n' % repr(self.shape)) # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL)
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3281; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3291, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = PyObject_Repr(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3281; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_Repr(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3291, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_current_shape_s, __pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3281; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_current_shape_s, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3291, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_2); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3281; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_2); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3291, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3282
+ /* "netCDF4/_netCDF4.pyx":3292
* ncdump_var.append('unlimited dimensions: %s\n' % ', '.join(unlimdims))
* ncdump_var.append('current shape = %s\n' % repr(self.shape))
* with nogil: # <<<<<<<<<<<<<<
@@ -30610,7 +30537,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3283
+ /* "netCDF4/_netCDF4.pyx":3293
* ncdump_var.append('current shape = %s\n' % repr(self.shape))
* with nogil:
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL) # <<<<<<<<<<<<<<
@@ -30620,7 +30547,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__pyx_v_ierr = nc_inq_var_fill(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_no_fill), NULL);
}
- /* "netCDF4/_netCDF4.pyx":3282
+ /* "netCDF4/_netCDF4.pyx":3292
* ncdump_var.append('unlimited dimensions: %s\n' % ', '.join(unlimdims))
* ncdump_var.append('current shape = %s\n' % repr(self.shape))
* with nogil: # <<<<<<<<<<<<<<
@@ -30638,7 +30565,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
}
}
- /* "netCDF4/_netCDF4.pyx":3284
+ /* "netCDF4/_netCDF4.pyx":3294
* with nogil:
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -30648,7 +30575,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__pyx_t_4 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3285
+ /* "netCDF4/_netCDF4.pyx":3295
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -30656,22 +30583,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
* if no_fill != 1:
*/
__pyx_t_13 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_2 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3285; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3295, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3285; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3295, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3285; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3295, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3285; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3295, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3284
+ /* "netCDF4/_netCDF4.pyx":3294
* with nogil:
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -30680,17 +30607,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":3286
+ /* "netCDF4/_netCDF4.pyx":3296
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if self._isprimitive: # <<<<<<<<<<<<<<
* if no_fill != 1:
* try:
*/
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3286; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3296, __pyx_L1_error)
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3287
+ /* "netCDF4/_netCDF4.pyx":3297
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if self._isprimitive:
* if no_fill != 1: # <<<<<<<<<<<<<<
@@ -30700,7 +30627,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__pyx_t_4 = ((__pyx_v_no_fill != 1) != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3288
+ /* "netCDF4/_netCDF4.pyx":3298
* if self._isprimitive:
* if no_fill != 1:
* try: # <<<<<<<<<<<<<<
@@ -30708,25 +30635,27 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
* msg = 'filling on'
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3289
+ /* "netCDF4/_netCDF4.pyx":3299
* if no_fill != 1:
* try:
* fillval = self._FillValue # <<<<<<<<<<<<<<
* msg = 'filling on'
* except AttributeError:
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3289; __pyx_clineno = __LINE__; goto __pyx_L20_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3299, __pyx_L20_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_v_fillval = __pyx_t_2;
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3290
+ /* "netCDF4/_netCDF4.pyx":3300
* try:
* fillval = self._FillValue
* msg = 'filling on' # <<<<<<<<<<<<<<
@@ -30736,7 +30665,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__Pyx_INCREF(__pyx_kp_s_filling_on);
__pyx_v_msg = __pyx_kp_s_filling_on;
- /* "netCDF4/_netCDF4.pyx":3288
+ /* "netCDF4/_netCDF4.pyx":3298
* if self._isprimitive:
* if no_fill != 1:
* try: # <<<<<<<<<<<<<<
@@ -30749,6 +30678,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
goto __pyx_L27_try_end;
__pyx_L20_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -30756,80 +30686,80 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3291
+ /* "netCDF4/_netCDF4.pyx":3301
* fillval = self._FillValue
* msg = 'filling on'
* except AttributeError: # <<<<<<<<<<<<<<
* fillval = default_fillvals[self.dtype.str[1:]]
* if self.dtype.str[1:] in ['u1','i1']:
*/
- __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
+ __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
if (__pyx_t_17) {
__Pyx_AddTraceback("netCDF4._netCDF4.Variable.__unicode__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_5, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3291; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(0, 3301, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_1);
- /* "netCDF4/_netCDF4.pyx":3292
+ /* "netCDF4/_netCDF4.pyx":3302
* msg = 'filling on'
* except AttributeError:
* fillval = default_fillvals[self.dtype.str[1:]] # <<<<<<<<<<<<<<
* if self.dtype.str[1:] in ['u1','i1']:
* msg = 'filling on, default _FillValue of %s ignored\n' % fillval
*/
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_fillvals); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3292; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_fillvals); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3302, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3292; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3302, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_10 = __Pyx_PyObject_GetSlice(__pyx_t_8, 1, 0, NULL, NULL, &__pyx_slice__45, 1, 0, 1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3292; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetSlice(__pyx_t_8, 1, 0, NULL, NULL, &__pyx_slice__45, 1, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3302, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = PyObject_GetItem(__pyx_t_9, __pyx_t_10); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3292; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;};
+ __pyx_t_8 = PyObject_GetItem(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3302, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF_SET(__pyx_v_fillval, __pyx_t_8);
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":3293
+ /* "netCDF4/_netCDF4.pyx":3303
* except AttributeError:
* fillval = default_fillvals[self.dtype.str[1:]]
* if self.dtype.str[1:] in ['u1','i1']: # <<<<<<<<<<<<<<
* msg = 'filling on, default _FillValue of %s ignored\n' % fillval
* else:
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3293; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3303, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_10 = __Pyx_PyObject_GetSlice(__pyx_t_8, 1, 0, NULL, NULL, &__pyx_slice__46, 1, 0, 1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3293; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetSlice(__pyx_t_8, 1, 0, NULL, NULL, &__pyx_slice__46, 1, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3303, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_10, __pyx_n_s_u1, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3293; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_10, __pyx_n_s_u1, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3303, __pyx_L22_except_error)
if (!__pyx_t_3) {
} else {
__pyx_t_4 = __pyx_t_3;
goto __pyx_L31_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_10, __pyx_n_s_i1, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3293; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_10, __pyx_n_s_i1, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3303, __pyx_L22_except_error)
__pyx_t_4 = __pyx_t_3;
__pyx_L31_bool_binop_done:;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_3 = (__pyx_t_4 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3294
+ /* "netCDF4/_netCDF4.pyx":3304
* fillval = default_fillvals[self.dtype.str[1:]]
* if self.dtype.str[1:] in ['u1','i1']:
* msg = 'filling on, default _FillValue of %s ignored\n' % fillval # <<<<<<<<<<<<<<
* else:
* msg = 'filling on, default _FillValue of %s used\n' % fillval
*/
- __pyx_t_10 = __Pyx_PyString_Format(__pyx_kp_s_filling_on_default__FillValue_of, __pyx_v_fillval); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3294; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_10 = __Pyx_PyString_Format(__pyx_kp_s_filling_on_default__FillValue_of, __pyx_v_fillval); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3304, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_XDECREF_SET(__pyx_v_msg, __pyx_t_10);
__pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":3293
+ /* "netCDF4/_netCDF4.pyx":3303
* except AttributeError:
* fillval = default_fillvals[self.dtype.str[1:]]
* if self.dtype.str[1:] in ['u1','i1']: # <<<<<<<<<<<<<<
@@ -30839,7 +30769,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
goto __pyx_L30;
}
- /* "netCDF4/_netCDF4.pyx":3296
+ /* "netCDF4/_netCDF4.pyx":3306
* msg = 'filling on, default _FillValue of %s ignored\n' % fillval
* else:
* msg = 'filling on, default _FillValue of %s used\n' % fillval # <<<<<<<<<<<<<<
@@ -30847,7 +30777,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
* else:
*/
/*else*/ {
- __pyx_t_10 = __Pyx_PyString_Format(__pyx_kp_s_filling_on_default__FillValue_of_2, __pyx_v_fillval); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3296; __pyx_clineno = __LINE__; goto __pyx_L22_except_error;}
+ __pyx_t_10 = __Pyx_PyString_Format(__pyx_kp_s_filling_on_default__FillValue_of_2, __pyx_v_fillval); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3306, __pyx_L22_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_XDECREF_SET(__pyx_v_msg, __pyx_t_10);
__pyx_t_10 = 0;
@@ -30861,19 +30791,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
goto __pyx_L22_except_error;
__pyx_L22_except_error:;
- /* "netCDF4/_netCDF4.pyx":3288
+ /* "netCDF4/_netCDF4.pyx":3298
* if self._isprimitive:
* if no_fill != 1:
* try: # <<<<<<<<<<<<<<
* fillval = self._FillValue
* msg = 'filling on'
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
goto __pyx_L1_error;
__pyx_L21_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
@@ -30881,16 +30813,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
__pyx_L27_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":3297
+ /* "netCDF4/_netCDF4.pyx":3307
* else:
* msg = 'filling on, default _FillValue of %s used\n' % fillval
* ncdump_var.append(msg) # <<<<<<<<<<<<<<
* else:
* ncdump_var.append('filling off\n')
*/
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_v_msg); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3297; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_v_msg); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3307, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3287
+ /* "netCDF4/_netCDF4.pyx":3297
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if self._isprimitive:
* if no_fill != 1: # <<<<<<<<<<<<<<
@@ -30900,7 +30832,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
goto __pyx_L19;
}
- /* "netCDF4/_netCDF4.pyx":3299
+ /* "netCDF4/_netCDF4.pyx":3309
* ncdump_var.append(msg)
* else:
* ncdump_var.append('filling off\n') # <<<<<<<<<<<<<<
@@ -30908,11 +30840,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
*
*/
/*else*/ {
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_kp_s_filling_off); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3299; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_kp_s_filling_off); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3309, __pyx_L1_error)
}
__pyx_L19:;
- /* "netCDF4/_netCDF4.pyx":3286
+ /* "netCDF4/_netCDF4.pyx":3296
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if self._isprimitive: # <<<<<<<<<<<<<<
@@ -30921,7 +30853,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
*/
}
- /* "netCDF4/_netCDF4.pyx":3302
+ /* "netCDF4/_netCDF4.pyx":3312
*
*
* return ''.join(ncdump_var) # <<<<<<<<<<<<<<
@@ -30929,13 +30861,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
* def _getdims(self):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_v_ncdump_var); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_v_ncdump_var); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3312, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3247
+ /* "netCDF4/_netCDF4.pyx":3257
* return unicode(self).encode(default_encoding)
*
* def __unicode__(self): # <<<<<<<<<<<<<<
@@ -30968,7 +30900,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6__unicode__(struct __pyx
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3304
+/* "netCDF4/_netCDF4.pyx":3314
* return ''.join(ncdump_var)
*
* def _getdims(self): # <<<<<<<<<<<<<<
@@ -31009,12 +30941,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
PyObject *__pyx_t_8 = NULL;
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_getdims", 0);
- /* "netCDF4/_netCDF4.pyx":3310
+ /* "netCDF4/_netCDF4.pyx":3320
* cdef int *dimids
* # get number of dimensions for this variable.
* with nogil: # <<<<<<<<<<<<<<
@@ -31028,7 +30957,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3311
+ /* "netCDF4/_netCDF4.pyx":3321
* # get number of dimensions for this variable.
* with nogil:
* ierr = nc_inq_varndims(self._grpid, self._varid, &numdims) # <<<<<<<<<<<<<<
@@ -31038,7 +30967,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_v_ierr = nc_inq_varndims(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_numdims));
}
- /* "netCDF4/_netCDF4.pyx":3310
+ /* "netCDF4/_netCDF4.pyx":3320
* cdef int *dimids
* # get number of dimensions for this variable.
* with nogil: # <<<<<<<<<<<<<<
@@ -31056,7 +30985,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
}
}
- /* "netCDF4/_netCDF4.pyx":3312
+ /* "netCDF4/_netCDF4.pyx":3322
* with nogil:
* ierr = nc_inq_varndims(self._grpid, self._varid, &numdims)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -31066,7 +30995,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3313
+ /* "netCDF4/_netCDF4.pyx":3323
* ierr = nc_inq_varndims(self._grpid, self._varid, &numdims)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -31074,22 +31003,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
* # get dimension ids.
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3323, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3323, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3323, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3313; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3323, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3312
+ /* "netCDF4/_netCDF4.pyx":3322
* with nogil:
* ierr = nc_inq_varndims(self._grpid, self._varid, &numdims)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -31098,7 +31027,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3314
+ /* "netCDF4/_netCDF4.pyx":3324
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* dimids = <int *>malloc(sizeof(int) * numdims) # <<<<<<<<<<<<<<
@@ -31107,7 +31036,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
*/
__pyx_v_dimids = ((int *)malloc(((sizeof(int)) * __pyx_v_numdims)));
- /* "netCDF4/_netCDF4.pyx":3316
+ /* "netCDF4/_netCDF4.pyx":3326
* dimids = <int *>malloc(sizeof(int) * numdims)
* # get dimension ids.
* with nogil: # <<<<<<<<<<<<<<
@@ -31121,7 +31050,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3317
+ /* "netCDF4/_netCDF4.pyx":3327
* # get dimension ids.
* with nogil:
* ierr = nc_inq_vardimid(self._grpid, self._varid, dimids) # <<<<<<<<<<<<<<
@@ -31131,7 +31060,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_v_ierr = nc_inq_vardimid(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_dimids);
}
- /* "netCDF4/_netCDF4.pyx":3316
+ /* "netCDF4/_netCDF4.pyx":3326
* dimids = <int *>malloc(sizeof(int) * numdims)
* # get dimension ids.
* with nogil: # <<<<<<<<<<<<<<
@@ -31149,7 +31078,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
}
}
- /* "netCDF4/_netCDF4.pyx":3318
+ /* "netCDF4/_netCDF4.pyx":3328
* with nogil:
* ierr = nc_inq_vardimid(self._grpid, self._varid, dimids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -31159,7 +31088,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3319
+ /* "netCDF4/_netCDF4.pyx":3329
* ierr = nc_inq_vardimid(self._grpid, self._varid, dimids)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -31167,22 +31096,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
* dimensions = ()
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3329, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3329, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3329, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3319; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3329, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3318
+ /* "netCDF4/_netCDF4.pyx":3328
* with nogil:
* ierr = nc_inq_vardimid(self._grpid, self._varid, dimids)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -31191,7 +31120,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3321
+ /* "netCDF4/_netCDF4.pyx":3331
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # loop over dimensions, retrieve names.
* dimensions = () # <<<<<<<<<<<<<<
@@ -31201,7 +31130,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_v_dimensions = __pyx_empty_tuple;
- /* "netCDF4/_netCDF4.pyx":3322
+ /* "netCDF4/_netCDF4.pyx":3332
* # loop over dimensions, retrieve names.
* dimensions = ()
* for nn from 0 <= nn < numdims: # <<<<<<<<<<<<<<
@@ -31211,7 +31140,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_t_5 = __pyx_v_numdims;
for (__pyx_v_nn = 0; __pyx_v_nn < __pyx_t_5; __pyx_v_nn++) {
- /* "netCDF4/_netCDF4.pyx":3323
+ /* "netCDF4/_netCDF4.pyx":3333
* dimensions = ()
* for nn from 0 <= nn < numdims:
* with nogil: # <<<<<<<<<<<<<<
@@ -31225,7 +31154,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3324
+ /* "netCDF4/_netCDF4.pyx":3334
* for nn from 0 <= nn < numdims:
* with nogil:
* ierr = nc_inq_dimname(self._grpid, dimids[nn], namstring) # <<<<<<<<<<<<<<
@@ -31235,7 +31164,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_v_ierr = nc_inq_dimname(__pyx_v_self->_grpid, (__pyx_v_dimids[__pyx_v_nn]), __pyx_v_namstring);
}
- /* "netCDF4/_netCDF4.pyx":3323
+ /* "netCDF4/_netCDF4.pyx":3333
* dimensions = ()
* for nn from 0 <= nn < numdims:
* with nogil: # <<<<<<<<<<<<<<
@@ -31253,7 +31182,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
}
}
- /* "netCDF4/_netCDF4.pyx":3325
+ /* "netCDF4/_netCDF4.pyx":3335
* with nogil:
* ierr = nc_inq_dimname(self._grpid, dimids[nn], namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -31263,7 +31192,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3326
+ /* "netCDF4/_netCDF4.pyx":3336
* ierr = nc_inq_dimname(self._grpid, dimids[nn], namstring)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -31271,22 +31200,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
* dimensions = dimensions + (name,)
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3326; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3336, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3326; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3336, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3326; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3336, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3326; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3336, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3325
+ /* "netCDF4/_netCDF4.pyx":3335
* with nogil:
* ierr = nc_inq_dimname(self._grpid, dimids[nn], namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -31295,21 +31224,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3327
+ /* "netCDF4/_netCDF4.pyx":3337
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
* dimensions = dimensions + (name,)
* free(dimids)
*/
- __pyx_t_4 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3327; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3327; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3327; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3327; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -31323,7 +31252,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3327; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -31334,33 +31263,33 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_4 = 0;
__pyx_t_7 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3327; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3328
+ /* "netCDF4/_netCDF4.pyx":3338
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* name = namstring.decode(default_encoding,unicode_error)
* dimensions = dimensions + (name,) # <<<<<<<<<<<<<<
* free(dimids)
* return dimensions
*/
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3328; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3338, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_name);
- __pyx_t_6 = PyNumber_Add(__pyx_v_dimensions, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3328; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Add(__pyx_v_dimensions, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3338, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_dimensions, ((PyObject*)__pyx_t_6));
__pyx_t_6 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3329
+ /* "netCDF4/_netCDF4.pyx":3339
* name = namstring.decode(default_encoding,unicode_error)
* dimensions = dimensions + (name,)
* free(dimids) # <<<<<<<<<<<<<<
@@ -31369,7 +31298,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
*/
free(__pyx_v_dimids);
- /* "netCDF4/_netCDF4.pyx":3330
+ /* "netCDF4/_netCDF4.pyx":3340
* dimensions = dimensions + (name,)
* free(dimids)
* return dimensions # <<<<<<<<<<<<<<
@@ -31381,7 +31310,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
__pyx_r = __pyx_v_dimensions;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3304
+ /* "netCDF4/_netCDF4.pyx":3314
* return ''.join(ncdump_var)
*
* def _getdims(self): # <<<<<<<<<<<<<<
@@ -31407,7 +31336,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8_getdims(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3332
+/* "netCDF4/_netCDF4.pyx":3342
* return dimensions
*
* def _getname(self): # <<<<<<<<<<<<<<
@@ -31444,25 +31373,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
PyObject *__pyx_t_8 = NULL;
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_getname", 0);
- /* "netCDF4/_netCDF4.pyx":3336
+ /* "netCDF4/_netCDF4.pyx":3346
* cdef int err, _grpid
* cdef char namstring[NC_MAX_NAME+1]
* _grpid = self._grp._grpid # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_varname(_grpid, self._varid, namstring)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3336; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3346, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3336; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3346, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":3337
+ /* "netCDF4/_netCDF4.pyx":3347
* cdef char namstring[NC_MAX_NAME+1]
* _grpid = self._grp._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -31476,7 +31402,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3338
+ /* "netCDF4/_netCDF4.pyx":3348
* _grpid = self._grp._grpid
* with nogil:
* ierr = nc_inq_varname(_grpid, self._varid, namstring) # <<<<<<<<<<<<<<
@@ -31486,7 +31412,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
__pyx_v_ierr = nc_inq_varname(__pyx_v__grpid, __pyx_v_self->_varid, __pyx_v_namstring);
}
- /* "netCDF4/_netCDF4.pyx":3337
+ /* "netCDF4/_netCDF4.pyx":3347
* cdef char namstring[NC_MAX_NAME+1]
* _grpid = self._grp._grpid
* with nogil: # <<<<<<<<<<<<<<
@@ -31504,7 +31430,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
}
}
- /* "netCDF4/_netCDF4.pyx":3339
+ /* "netCDF4/_netCDF4.pyx":3349
* with nogil:
* ierr = nc_inq_varname(_grpid, self._varid, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -31514,7 +31440,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3340
+ /* "netCDF4/_netCDF4.pyx":3350
* ierr = nc_inq_varname(_grpid, self._varid, namstring)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -31522,22 +31448,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
*
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3340; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3340; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3340; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3340; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3350, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3339
+ /* "netCDF4/_netCDF4.pyx":3349
* with nogil:
* ierr = nc_inq_varname(_grpid, self._varid, namstring)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -31546,7 +31472,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
*/
}
- /* "netCDF4/_netCDF4.pyx":3341
+ /* "netCDF4/_netCDF4.pyx":3351
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* return namstring.decode(default_encoding,unicode_error) # <<<<<<<<<<<<<<
@@ -31554,14 +31480,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
* property name:
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3341; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3341; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3341; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3341; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -31575,7 +31501,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3341; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -31586,7 +31512,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3341; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3351, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -31594,7 +31520,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3332
+ /* "netCDF4/_netCDF4.pyx":3342
* return dimensions
*
* def _getname(self): # <<<<<<<<<<<<<<
@@ -31618,7 +31544,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_getname(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3345
+/* "netCDF4/_netCDF4.pyx":3355
* property name:
* """string name of Variable instance"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -31645,12 +31571,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4name___get__(struct __py
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
- /* "netCDF4/_netCDF4.pyx":3346
+ /* "netCDF4/_netCDF4.pyx":3356
* """string name of Variable instance"""
* def __get__(self):
* return self._getname() # <<<<<<<<<<<<<<
@@ -31658,7 +31581,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4name___get__(struct __py
* raise AttributeError("name cannot be altered")
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getname); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3346; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3356, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -31671,10 +31594,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4name___get__(struct __py
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3346; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3356, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3346; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3356, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -31682,7 +31605,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4name___get__(struct __py
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3345
+ /* "netCDF4/_netCDF4.pyx":3355
* property name:
* """string name of Variable instance"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -31703,7 +31626,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4name___get__(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3347
+/* "netCDF4/_netCDF4.pyx":3357
* def __get__(self):
* return self._getname()
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -31728,25 +31651,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_4name_2__set__(CYTHON_UNUSED st
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- /* "netCDF4/_netCDF4.pyx":3348
+ /* "netCDF4/_netCDF4.pyx":3358
* return self._getname()
* def __set__(self,value):
* raise AttributeError("name cannot be altered") # <<<<<<<<<<<<<<
*
* property datatype:
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3358, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3358, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3347
+ /* "netCDF4/_netCDF4.pyx":3357
* def __get__(self):
* return self._getname()
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -31763,7 +31683,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_4name_2__set__(CYTHON_UNUSED st
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3354
+/* "netCDF4/_netCDF4.pyx":3364
* VLType/CompoundType/EnumType instance
* (for compound, vlen or enum data types)"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -31788,22 +31708,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
- /* "netCDF4/_netCDF4.pyx":3355
+ /* "netCDF4/_netCDF4.pyx":3365
* (for compound, vlen or enum data types)"""
* def __get__(self):
* if self._iscompound: # <<<<<<<<<<<<<<
* return self._cmptype
* elif self._isvlen:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3355; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3365, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3356
+ /* "netCDF4/_netCDF4.pyx":3366
* def __get__(self):
* if self._iscompound:
* return self._cmptype # <<<<<<<<<<<<<<
@@ -31815,7 +31732,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
__pyx_r = __pyx_v_self->_cmptype;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3355
+ /* "netCDF4/_netCDF4.pyx":3365
* (for compound, vlen or enum data types)"""
* def __get__(self):
* if self._iscompound: # <<<<<<<<<<<<<<
@@ -31824,17 +31741,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
*/
}
- /* "netCDF4/_netCDF4.pyx":3357
+ /* "netCDF4/_netCDF4.pyx":3367
* if self._iscompound:
* return self._cmptype
* elif self._isvlen: # <<<<<<<<<<<<<<
* return self._vltype
* elif self._isenum:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3367, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3358
+ /* "netCDF4/_netCDF4.pyx":3368
* return self._cmptype
* elif self._isvlen:
* return self._vltype # <<<<<<<<<<<<<<
@@ -31846,7 +31763,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
__pyx_r = __pyx_v_self->_vltype;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3357
+ /* "netCDF4/_netCDF4.pyx":3367
* if self._iscompound:
* return self._cmptype
* elif self._isvlen: # <<<<<<<<<<<<<<
@@ -31855,17 +31772,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
*/
}
- /* "netCDF4/_netCDF4.pyx":3359
+ /* "netCDF4/_netCDF4.pyx":3369
* elif self._isvlen:
* return self._vltype
* elif self._isenum: # <<<<<<<<<<<<<<
* return self._enumtype
* elif self._isprimitive:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3359; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3369, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3360
+ /* "netCDF4/_netCDF4.pyx":3370
* return self._vltype
* elif self._isenum:
* return self._enumtype # <<<<<<<<<<<<<<
@@ -31877,7 +31794,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
__pyx_r = __pyx_v_self->_enumtype;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3359
+ /* "netCDF4/_netCDF4.pyx":3369
* elif self._isvlen:
* return self._vltype
* elif self._isenum: # <<<<<<<<<<<<<<
@@ -31886,17 +31803,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
*/
}
- /* "netCDF4/_netCDF4.pyx":3361
+ /* "netCDF4/_netCDF4.pyx":3371
* elif self._isenum:
* return self._enumtype
* elif self._isprimitive: # <<<<<<<<<<<<<<
* return self.dtype
*
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3361; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3371, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3362
+ /* "netCDF4/_netCDF4.pyx":3372
* return self._enumtype
* elif self._isprimitive:
* return self.dtype # <<<<<<<<<<<<<<
@@ -31908,7 +31825,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
__pyx_r = __pyx_v_self->dtype;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3361
+ /* "netCDF4/_netCDF4.pyx":3371
* elif self._isenum:
* return self._enumtype
* elif self._isprimitive: # <<<<<<<<<<<<<<
@@ -31917,7 +31834,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
*/
}
- /* "netCDF4/_netCDF4.pyx":3354
+ /* "netCDF4/_netCDF4.pyx":3364
* VLType/CompoundType/EnumType instance
* (for compound, vlen or enum data types)"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -31937,7 +31854,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_8datatype___get__(struct
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3366
+/* "netCDF4/_netCDF4.pyx":3376
* property shape:
* """find current sizes of all variable dimensions"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -31972,12 +31889,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
PyObject *__pyx_t_6 = NULL;
Py_ssize_t __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
- /* "netCDF4/_netCDF4.pyx":3367
+ /* "netCDF4/_netCDF4.pyx":3377
* """find current sizes of all variable dimensions"""
* def __get__(self):
* shape = () # <<<<<<<<<<<<<<
@@ -31987,14 +31901,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_v_shape = __pyx_empty_tuple;
- /* "netCDF4/_netCDF4.pyx":3368
+ /* "netCDF4/_netCDF4.pyx":3378
* def __get__(self):
* shape = ()
* for dimname in self._getdims(): # <<<<<<<<<<<<<<
* # look in current group, and parents for dim.
* dim = _find_dim(self._grp,dimname)
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getdims); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getdims); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -32007,10 +31921,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3378, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3378, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -32018,9 +31932,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3378, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -32028,17 +31942,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 3378, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 3378, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -32048,7 +31962,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3378, __pyx_L1_error)
}
break;
}
@@ -32057,14 +31971,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3370
+ /* "netCDF4/_netCDF4.pyx":3380
* for dimname in self._getdims():
* # look in current group, and parents for dim.
* dim = _find_dim(self._grp,dimname) # <<<<<<<<<<<<<<
* shape = shape + (len(dim),)
* return shape
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = NULL;
__pyx_t_7 = 0;
@@ -32078,7 +31992,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
__pyx_t_7 = 1;
}
}
- __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
@@ -32089,35 +32003,35 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_dimname);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF_SET(__pyx_v_dim, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3371
+ /* "netCDF4/_netCDF4.pyx":3381
* # look in current group, and parents for dim.
* dim = _find_dim(self._grp,dimname)
* shape = shape + (len(dim),) # <<<<<<<<<<<<<<
* return shape
* def __set__(self,value):
*/
- __pyx_t_7 = PyObject_Length(__pyx_v_dim); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_Length(__pyx_v_dim); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 3381, __pyx_L1_error)
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_Add(__pyx_v_shape, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_v_shape, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_shape, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3368
+ /* "netCDF4/_netCDF4.pyx":3378
* def __get__(self):
* shape = ()
* for dimname in self._getdims(): # <<<<<<<<<<<<<<
@@ -32127,7 +32041,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3372
+ /* "netCDF4/_netCDF4.pyx":3382
* dim = _find_dim(self._grp,dimname)
* shape = shape + (len(dim),)
* return shape # <<<<<<<<<<<<<<
@@ -32139,7 +32053,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
__pyx_r = __pyx_v_shape;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3366
+ /* "netCDF4/_netCDF4.pyx":3376
* property shape:
* """find current sizes of all variable dimensions"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -32165,7 +32079,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape___get__(struct __p
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3373
+/* "netCDF4/_netCDF4.pyx":3383
* shape = shape + (len(dim),)
* return shape
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -32190,25 +32104,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape_2__set__(CYTHON_UNUSED s
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- /* "netCDF4/_netCDF4.pyx":3374
+ /* "netCDF4/_netCDF4.pyx":3384
* return shape
* def __set__(self,value):
* raise AttributeError("shape cannot be altered") # <<<<<<<<<<<<<<
*
* property size:
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3374; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3384, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3374; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3384, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3373
+ /* "netCDF4/_netCDF4.pyx":3383
* shape = shape + (len(dim),)
* return shape
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -32225,7 +32136,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_5shape_2__set__(CYTHON_UNUSED s
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3378
+/* "netCDF4/_netCDF4.pyx":3388
* property size:
* """Return the number of stored elements."""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -32254,12 +32165,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4size___get__(struct __py
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
- /* "netCDF4/_netCDF4.pyx":3379
+ /* "netCDF4/_netCDF4.pyx":3389
* """Return the number of stored elements."""
* def __get__(self):
* return numpy.prod(self.shape) # <<<<<<<<<<<<<<
@@ -32267,12 +32175,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4size___get__(struct __py
* property dimensions:
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3379; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3389, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_prod); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3379; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_prod); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3389, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3379; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3389, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) {
@@ -32285,17 +32193,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4size___get__(struct __py
}
}
if (!__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3379; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3389, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3379; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3389, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3379; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3389, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
@@ -32304,7 +32212,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4size___get__(struct __py
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3378
+ /* "netCDF4/_netCDF4.pyx":3388
* property size:
* """Return the number of stored elements."""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -32327,7 +32235,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_4size___get__(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3383
+/* "netCDF4/_netCDF4.pyx":3393
* property dimensions:
* """get variables's dimension names"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -32354,12 +32262,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10dimensions___get__(stru
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
- /* "netCDF4/_netCDF4.pyx":3384
+ /* "netCDF4/_netCDF4.pyx":3394
* """get variables's dimension names"""
* def __get__(self):
* return self._getdims() # <<<<<<<<<<<<<<
@@ -32367,7 +32272,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10dimensions___get__(stru
* raise AttributeError("dimensions cannot be altered")
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getdims); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getdims); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -32380,10 +32285,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10dimensions___get__(stru
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3394, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3394, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -32391,7 +32296,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10dimensions___get__(stru
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3383
+ /* "netCDF4/_netCDF4.pyx":3393
* property dimensions:
* """get variables's dimension names"""
* def __get__(self): # <<<<<<<<<<<<<<
@@ -32412,7 +32317,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10dimensions___get__(stru
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3385
+/* "netCDF4/_netCDF4.pyx":3395
* def __get__(self):
* return self._getdims()
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -32437,25 +32342,22 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_10dimensions_2__set__(CYTHON_UN
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- /* "netCDF4/_netCDF4.pyx":3386
+ /* "netCDF4/_netCDF4.pyx":3396
* return self._getdims()
* def __set__(self,value):
* raise AttributeError("dimensions cannot be altered") # <<<<<<<<<<<<<<
*
*
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3386; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3396, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3386; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3396, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3385
+ /* "netCDF4/_netCDF4.pyx":3395
* def __get__(self):
* return self._getdims()
* def __set__(self,value): # <<<<<<<<<<<<<<
@@ -32472,7 +32374,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_10dimensions_2__set__(CYTHON_UN
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3389
+/* "netCDF4/_netCDF4.pyx":3399
*
*
* def group(self): # <<<<<<<<<<<<<<
@@ -32499,7 +32401,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_12group(struct __pyx_obj_
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("group", 0);
- /* "netCDF4/_netCDF4.pyx":3394
+ /* "netCDF4/_netCDF4.pyx":3404
*
* return the group that this `netCDF4.Variable` is a member of."""
* return self._grp # <<<<<<<<<<<<<<
@@ -32511,7 +32413,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_12group(struct __pyx_obj_
__pyx_r = __pyx_v_self->_grp;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3389
+ /* "netCDF4/_netCDF4.pyx":3399
*
*
* def group(self): # <<<<<<<<<<<<<<
@@ -32526,7 +32428,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_12group(struct __pyx_obj_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3396
+/* "netCDF4/_netCDF4.pyx":3406
* return self._grp
*
* def ncattrs(self): # <<<<<<<<<<<<<<
@@ -32552,12 +32454,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_14ncattrs(struct __pyx_ob
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("ncattrs", 0);
- /* "netCDF4/_netCDF4.pyx":3401
+ /* "netCDF4/_netCDF4.pyx":3411
*
* return netCDF attribute names for this `netCDF4.Variable` in a list."""
* return _get_att_names(self._grpid, self._varid) # <<<<<<<<<<<<<<
@@ -32565,13 +32464,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_14ncattrs(struct __pyx_ob
* def setncattr(self,name,value):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_att_names(__pyx_v_self->_grpid, __pyx_v_self->_varid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3401; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__get_att_names(__pyx_v_self->_grpid, __pyx_v_self->_varid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3411, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3396
+ /* "netCDF4/_netCDF4.pyx":3406
* return self._grp
*
* def ncattrs(self): # <<<<<<<<<<<<<<
@@ -32590,7 +32489,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_14ncattrs(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3403
+/* "netCDF4/_netCDF4.pyx":3413
* return _get_att_names(self._grpid, self._varid)
*
* def setncattr(self,name,value): # <<<<<<<<<<<<<<
@@ -32604,9 +32503,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_8Variable_16setncattr[] = "\n**`setncat
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_17setncattr(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_name = 0;
PyObject *__pyx_v_value = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("setncattr (wrapper)", 0);
@@ -32630,11 +32526,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_17setncattr(PyObject *__p
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("setncattr", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3403; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("setncattr", 1, 2, 2, 1); __PYX_ERR(0, 3413, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setncattr") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3403; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setncattr") < 0)) __PYX_ERR(0, 3413, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -32647,7 +32543,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_17setncattr(PyObject *__p
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("setncattr", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3403; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("setncattr", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3413, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Variable.setncattr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -32667,24 +32563,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_16setncattr(struct __pyx_
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setncattr", 0);
- /* "netCDF4/_netCDF4.pyx":3410
+ /* "netCDF4/_netCDF4.pyx":3420
* netCDF attribute with the same name as one of the reserved python
* attributes."""
* if self._grp.data_model != 'NETCDF4': self._grp._redef() # <<<<<<<<<<<<<<
* _set_att(self._grp, self._varid, name, value)
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3410; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3420, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3410; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3420, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3410; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3420, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -32697,17 +32590,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_16setncattr(struct __pyx_
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3410; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3420, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3410; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3420, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3411
+ /* "netCDF4/_netCDF4.pyx":3421
* attributes."""
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
* _set_att(self._grp, self._varid, name, value) # <<<<<<<<<<<<<<
@@ -32716,24 +32609,24 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_16setncattr(struct __pyx_
*/
__pyx_t_1 = __pyx_v_self->_grp;
__Pyx_INCREF(__pyx_t_1);
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__set_att(__pyx_t_1, __pyx_v_self->_varid, __pyx_v_name, __pyx_v_value, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__set_att(__pyx_t_1, __pyx_v_self->_varid, __pyx_v_name, __pyx_v_value, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3421, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3412
+ /* "netCDF4/_netCDF4.pyx":3422
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
* _set_att(self._grp, self._varid, name, value)
* if self._grp.data_model != 'NETCDF4': self._grp._enddef() # <<<<<<<<<<<<<<
*
* def setncattr_string(self,name,value):
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3422, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -32746,17 +32639,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_16setncattr(struct __pyx_
}
}
if (__pyx_t_4) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3422, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3422, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3403
+ /* "netCDF4/_netCDF4.pyx":3413
* return _get_att_names(self._grpid, self._varid)
*
* def setncattr(self,name,value): # <<<<<<<<<<<<<<
@@ -32779,7 +32672,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_16setncattr(struct __pyx_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3414
+/* "netCDF4/_netCDF4.pyx":3424
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
*
* def setncattr_string(self,name,value): # <<<<<<<<<<<<<<
@@ -32793,9 +32686,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_8Variable_18setncattr_string[] = "\n**`
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_19setncattr_string(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_name = 0;
PyObject *__pyx_v_value = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("setncattr_string (wrapper)", 0);
@@ -32819,11 +32709,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_19setncattr_string(PyObje
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("setncattr_string", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3414; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("setncattr_string", 1, 2, 2, 1); __PYX_ERR(0, 3424, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setncattr_string") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3414; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setncattr_string") < 0)) __PYX_ERR(0, 3424, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -32836,7 +32726,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_19setncattr_string(PyObje
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("setncattr_string", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3414; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("setncattr_string", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3424, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Variable.setncattr_string", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -32859,12 +32749,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_18setncattr_string(struct
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
struct __pyx_opt_args_7netCDF4_8_netCDF4__set_att __pyx_t_5;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setncattr_string", 0);
- /* "netCDF4/_netCDF4.pyx":3422
+ /* "netCDF4/_netCDF4.pyx":3432
* `NC_STRING` if the file format is `NETCDF4`."""
* cdef nc_type xtype
* xtype=-99 # <<<<<<<<<<<<<<
@@ -32873,20 +32760,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_18setncattr_string(struct
*/
__pyx_v_xtype = -99;
- /* "netCDF4/_netCDF4.pyx":3423
+ /* "netCDF4/_netCDF4.pyx":3433
* cdef nc_type xtype
* xtype=-99
* if self._grp.data_model != 'NETCDF4': # <<<<<<<<<<<<<<
* msg='file format does not support NC_STRING attributes'
* raise IOError(msg)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3423; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3433, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3423; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3433, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3424
+ /* "netCDF4/_netCDF4.pyx":3434
* xtype=-99
* if self._grp.data_model != 'NETCDF4':
* msg='file format does not support NC_STRING attributes' # <<<<<<<<<<<<<<
@@ -32896,26 +32783,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_18setncattr_string(struct
__Pyx_INCREF(__pyx_kp_s_file_format_does_not_support_NC);
__pyx_v_msg = __pyx_kp_s_file_format_does_not_support_NC;
- /* "netCDF4/_netCDF4.pyx":3425
+ /* "netCDF4/_netCDF4.pyx":3435
* if self._grp.data_model != 'NETCDF4':
* msg='file format does not support NC_STRING attributes'
* raise IOError(msg) # <<<<<<<<<<<<<<
* _set_att(self._grp, self._varid, name, str(value), xtype=xtype, force_ncstring=True)
*
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3435, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3435, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3425; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3435, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3423
+ /* "netCDF4/_netCDF4.pyx":3433
* cdef nc_type xtype
* xtype=-99
* if self._grp.data_model != 'NETCDF4': # <<<<<<<<<<<<<<
@@ -32924,7 +32811,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_18setncattr_string(struct
*/
}
- /* "netCDF4/_netCDF4.pyx":3426
+ /* "netCDF4/_netCDF4.pyx":3436
* msg='file format does not support NC_STRING attributes'
* raise IOError(msg)
* _set_att(self._grp, self._varid, name, str(value), xtype=xtype, force_ncstring=True) # <<<<<<<<<<<<<<
@@ -32933,24 +32820,24 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_18setncattr_string(struct
*/
__pyx_t_3 = __pyx_v_self->_grp;
__Pyx_INCREF(__pyx_t_3);
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3426; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3436, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_value);
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3426; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3436, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_5.__pyx_n = 2;
__pyx_t_5.xtype = __pyx_v_xtype;
__pyx_t_5.force_ncstring = Py_True;
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__set_att(__pyx_t_3, __pyx_v_self->_varid, __pyx_v_name, __pyx_t_4, &__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3426; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__set_att(__pyx_t_3, __pyx_v_self->_varid, __pyx_v_name, __pyx_t_4, &__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3436, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3414
+ /* "netCDF4/_netCDF4.pyx":3424
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
*
* def setncattr_string(self,name,value): # <<<<<<<<<<<<<<
@@ -32974,7 +32861,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_18setncattr_string(struct
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3428
+/* "netCDF4/_netCDF4.pyx":3438
* _set_att(self._grp, self._varid, name, str(value), xtype=xtype, force_ncstring=True)
*
* def setncatts(self,attdict): # <<<<<<<<<<<<<<
@@ -33010,24 +32897,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *(*__pyx_t_9)(PyObject *);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("setncatts", 0);
- /* "netCDF4/_netCDF4.pyx":3436
+ /* "netCDF4/_netCDF4.pyx":3446
* formatted file, since nc_redef/nc_enddef is not called in between setting
* each attribute"""
* if self._grp.data_model != 'NETCDF4': self._grp._redef() # <<<<<<<<<<<<<<
* for name, value in attdict.items():
* _set_att(self._grp, self._varid, name, value)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3446, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3446, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3446, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -33040,24 +32924,24 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3446, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3436; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3446, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3437
+ /* "netCDF4/_netCDF4.pyx":3447
* each attribute"""
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
* for name, value in attdict.items(): # <<<<<<<<<<<<<<
* _set_att(self._grp, self._varid, name, value)
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_attdict, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_attdict, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -33070,10 +32954,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3447, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3447, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -33081,9 +32965,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
__pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3447, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -33091,17 +32975,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 3447, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 3447, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -33111,7 +32995,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3447, __pyx_L1_error)
}
break;
}
@@ -33127,7 +33011,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3447, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -33140,15 +33024,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_7);
#else
- __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext;
@@ -33156,7 +33040,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
__Pyx_GOTREF(__pyx_t_4);
index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L6_unpacking_failed;
__Pyx_GOTREF(__pyx_t_7);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(0, 3447, __pyx_L1_error)
__pyx_t_9 = NULL;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L7_unpacking_done;
@@ -33164,7 +33048,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3437; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3447, __pyx_L1_error)
__pyx_L7_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_4);
@@ -33172,7 +33056,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
__Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3438
+ /* "netCDF4/_netCDF4.pyx":3448
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
* for name, value in attdict.items():
* _set_att(self._grp, self._varid, name, value) # <<<<<<<<<<<<<<
@@ -33181,12 +33065,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
*/
__pyx_t_1 = __pyx_v_self->_grp;
__Pyx_INCREF(__pyx_t_1);
- __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__set_att(__pyx_t_1, __pyx_v_self->_varid, __pyx_v_name, __pyx_v_value, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__set_att(__pyx_t_1, __pyx_v_self->_varid, __pyx_v_name, __pyx_v_value, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3437
+ /* "netCDF4/_netCDF4.pyx":3447
* each attribute"""
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
* for name, value in attdict.items(): # <<<<<<<<<<<<<<
@@ -33196,19 +33080,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3439
+ /* "netCDF4/_netCDF4.pyx":3449
* for name, value in attdict.items():
* _set_att(self._grp, self._varid, name, value)
* if self._grp.data_model != 'NETCDF4': self._grp._enddef() # <<<<<<<<<<<<<<
*
* def getncattr(self,name):
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_3, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3449, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_2) {
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_1 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -33221,17 +33105,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
}
}
if (__pyx_t_1) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3449, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3449, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3428
+ /* "netCDF4/_netCDF4.pyx":3438
* _set_att(self._grp, self._varid, name, str(value), xtype=xtype, force_ncstring=True)
*
* def setncatts(self,attdict): # <<<<<<<<<<<<<<
@@ -33258,7 +33142,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_20setncatts(struct __pyx_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3441
+/* "netCDF4/_netCDF4.pyx":3451
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
*
* def getncattr(self,name): # <<<<<<<<<<<<<<
@@ -33285,12 +33169,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_22getncattr(struct __pyx_
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("getncattr", 0);
- /* "netCDF4/_netCDF4.pyx":3448
+ /* "netCDF4/_netCDF4.pyx":3458
* netCDF attribute with the same name as one of the reserved python
* attributes."""
* return _get_att(self._grp, self._varid, name) # <<<<<<<<<<<<<<
@@ -33300,14 +33181,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_22getncattr(struct __pyx_
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __pyx_v_self->_grp;
__Pyx_INCREF(__pyx_t_1);
- __pyx_t_2 = __pyx_f_7netCDF4_8_netCDF4__get_att(__pyx_t_1, __pyx_v_self->_varid, __pyx_v_name); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3448; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __pyx_f_7netCDF4_8_netCDF4__get_att(__pyx_t_1, __pyx_v_self->_varid, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3458, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3441
+ /* "netCDF4/_netCDF4.pyx":3451
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
*
* def getncattr(self,name): # <<<<<<<<<<<<<<
@@ -33327,7 +33208,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_22getncattr(struct __pyx_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3450
+/* "netCDF4/_netCDF4.pyx":3460
* return _get_att(self._grp, self._varid, name)
*
* def delncattr(self, name): # <<<<<<<<<<<<<<
@@ -33360,46 +33241,43 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_24delncattr(struct __pyx_
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("delncattr", 0);
- /* "netCDF4/_netCDF4.pyx":3458
+ /* "netCDF4/_netCDF4.pyx":3468
* attributes."""
* cdef char *attname
* bytestr = _strencode(name) # <<<<<<<<<<<<<<
* attname = bytestr
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3458; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3468, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3459
+ /* "netCDF4/_netCDF4.pyx":3469
* cdef char *attname
* bytestr = _strencode(name)
* attname = bytestr # <<<<<<<<<<<<<<
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
* ierr = nc_del_att(self._grpid, self._varid, attname)
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3459; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 3469, __pyx_L1_error)
__pyx_v_attname = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":3460
+ /* "netCDF4/_netCDF4.pyx":3470
* bytestr = _strencode(name)
* attname = bytestr
* if self._grp.data_model != 'NETCDF4': self._grp._redef() # <<<<<<<<<<<<<<
* ierr = nc_del_att(self._grpid, self._varid, attname)
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3470, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3470, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_redef); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3470, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -33412,17 +33290,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_24delncattr(struct __pyx_
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3470, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3460; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3470, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3461
+ /* "netCDF4/_netCDF4.pyx":3471
* attname = bytestr
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
* ierr = nc_del_att(self._grpid, self._varid, attname) # <<<<<<<<<<<<<<
@@ -33431,19 +33309,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_24delncattr(struct __pyx_
*/
__pyx_v_ierr = nc_del_att(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_attname);
- /* "netCDF4/_netCDF4.pyx":3462
+ /* "netCDF4/_netCDF4.pyx":3472
* if self._grp.data_model != 'NETCDF4': self._grp._redef()
* ierr = nc_del_att(self._grpid, self._varid, attname)
* if self._grp.data_model != 'NETCDF4': self._grp._enddef() # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3472, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3472, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_enddef); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3472, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -33456,17 +33334,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_24delncattr(struct __pyx_
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3472, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3472, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3463
+ /* "netCDF4/_netCDF4.pyx":3473
* ierr = nc_del_att(self._grpid, self._varid, attname)
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -33476,7 +33354,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_24delncattr(struct __pyx_
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3464
+ /* "netCDF4/_netCDF4.pyx":3474
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -33484,22 +33362,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_24delncattr(struct __pyx_
* def filters(self):
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3474, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3463
+ /* "netCDF4/_netCDF4.pyx":3473
* ierr = nc_del_att(self._grpid, self._varid, attname)
* if self._grp.data_model != 'NETCDF4': self._grp._enddef()
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -33508,7 +33386,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_24delncattr(struct __pyx_
*/
}
- /* "netCDF4/_netCDF4.pyx":3450
+ /* "netCDF4/_netCDF4.pyx":3460
* return _get_att(self._grp, self._varid, name)
*
* def delncattr(self, name): # <<<<<<<<<<<<<<
@@ -33532,7 +33410,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_24delncattr(struct __pyx_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3466
+/* "netCDF4/_netCDF4.pyx":3476
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def filters(self): # <<<<<<<<<<<<<<
@@ -33568,43 +33446,40 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
int __pyx_t_3;
char *__pyx_t_4;
PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("filters", 0);
- /* "netCDF4/_netCDF4.pyx":3472
+ /* "netCDF4/_netCDF4.pyx":3482
* return dictionary containing HDF5 filter parameters."""
* cdef int ierr,ideflate,ishuffle,ideflate_level,ifletcher32
* filtdict = {'zlib':False,'shuffle':False,'complevel':0,'fletcher32':False} # <<<<<<<<<<<<<<
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: return
* with nogil:
*/
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3472; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3482, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_zlib, Py_False) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3472; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_shuffle, Py_False) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3472; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_complevel, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3472; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_fletcher32, Py_False) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3472; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_zlib, Py_False) < 0) __PYX_ERR(0, 3482, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_shuffle, Py_False) < 0) __PYX_ERR(0, 3482, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_complevel, __pyx_int_0) < 0) __PYX_ERR(0, 3482, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_fletcher32, Py_False) < 0) __PYX_ERR(0, 3482, __pyx_L1_error)
__pyx_v_filtdict = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3473
+ /* "netCDF4/_netCDF4.pyx":3483
* cdef int ierr,ideflate,ishuffle,ideflate_level,ifletcher32
* filtdict = {'zlib':False,'shuffle':False,'complevel':0,'fletcher32':False}
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: return # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_inq_var_deflate(self._grpid, self._varid, &ishuffle, &ideflate, &ideflate_level)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3473; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4_CLASSIC, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3473; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4_CLASSIC, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3483, __pyx_L1_error)
if (__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3473; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3483, __pyx_L1_error)
__pyx_t_2 = __pyx_t_3;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -33615,7 +33490,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":3474
+ /* "netCDF4/_netCDF4.pyx":3484
* filtdict = {'zlib':False,'shuffle':False,'complevel':0,'fletcher32':False}
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: return
* with nogil: # <<<<<<<<<<<<<<
@@ -33629,7 +33504,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3475
+ /* "netCDF4/_netCDF4.pyx":3485
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: return
* with nogil:
* ierr = nc_inq_var_deflate(self._grpid, self._varid, &ishuffle, &ideflate, &ideflate_level) # <<<<<<<<<<<<<<
@@ -33639,7 +33514,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
__pyx_v_ierr = nc_inq_var_deflate(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_ishuffle), (&__pyx_v_ideflate), (&__pyx_v_ideflate_level));
}
- /* "netCDF4/_netCDF4.pyx":3474
+ /* "netCDF4/_netCDF4.pyx":3484
* filtdict = {'zlib':False,'shuffle':False,'complevel':0,'fletcher32':False}
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: return
* with nogil: # <<<<<<<<<<<<<<
@@ -33657,7 +33532,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
}
}
- /* "netCDF4/_netCDF4.pyx":3476
+ /* "netCDF4/_netCDF4.pyx":3486
* with nogil:
* ierr = nc_inq_var_deflate(self._grpid, self._varid, &ishuffle, &ideflate, &ideflate_level)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -33667,7 +33542,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3477
+ /* "netCDF4/_netCDF4.pyx":3487
* ierr = nc_inq_var_deflate(self._grpid, self._varid, &ishuffle, &ideflate, &ideflate_level)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -33675,22 +33550,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
* ierr = nc_inq_var_fletcher32(self._grpid, self._varid, &ifletcher32)
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3477; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3487, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3477; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3487, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3477; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3487, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3477; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3487, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3476
+ /* "netCDF4/_netCDF4.pyx":3486
* with nogil:
* ierr = nc_inq_var_deflate(self._grpid, self._varid, &ishuffle, &ideflate, &ideflate_level)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -33699,7 +33574,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3478
+ /* "netCDF4/_netCDF4.pyx":3488
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* with nogil: # <<<<<<<<<<<<<<
@@ -33713,7 +33588,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3479
+ /* "netCDF4/_netCDF4.pyx":3489
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* with nogil:
* ierr = nc_inq_var_fletcher32(self._grpid, self._varid, &ifletcher32) # <<<<<<<<<<<<<<
@@ -33723,7 +33598,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
__pyx_v_ierr = nc_inq_var_fletcher32(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_ifletcher32));
}
- /* "netCDF4/_netCDF4.pyx":3478
+ /* "netCDF4/_netCDF4.pyx":3488
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* with nogil: # <<<<<<<<<<<<<<
@@ -33741,7 +33616,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
}
}
- /* "netCDF4/_netCDF4.pyx":3480
+ /* "netCDF4/_netCDF4.pyx":3490
* with nogil:
* ierr = nc_inq_var_fletcher32(self._grpid, self._varid, &ifletcher32)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -33751,7 +33626,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3481
+ /* "netCDF4/_netCDF4.pyx":3491
* ierr = nc_inq_var_fletcher32(self._grpid, self._varid, &ifletcher32)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -33759,22 +33634,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
* filtdict['zlib']=True
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3481; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3491, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3481; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3491, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3481; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3491, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3481; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3491, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3480
+ /* "netCDF4/_netCDF4.pyx":3490
* with nogil:
* ierr = nc_inq_var_fletcher32(self._grpid, self._varid, &ifletcher32)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -33783,7 +33658,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3482
+ /* "netCDF4/_netCDF4.pyx":3492
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ideflate: # <<<<<<<<<<<<<<
@@ -33793,28 +33668,28 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
__pyx_t_3 = (__pyx_v_ideflate != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3483
+ /* "netCDF4/_netCDF4.pyx":3493
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ideflate:
* filtdict['zlib']=True # <<<<<<<<<<<<<<
* filtdict['complevel']=ideflate_level
* if ishuffle:
*/
- if (unlikely(PyDict_SetItem(__pyx_v_filtdict, __pyx_n_s_zlib, Py_True) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3483; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItem(__pyx_v_filtdict, __pyx_n_s_zlib, Py_True) < 0)) __PYX_ERR(0, 3493, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3484
+ /* "netCDF4/_netCDF4.pyx":3494
* if ideflate:
* filtdict['zlib']=True
* filtdict['complevel']=ideflate_level # <<<<<<<<<<<<<<
* if ishuffle:
* filtdict['shuffle']=True
*/
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ideflate_level); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3484; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_ideflate_level); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3494, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(PyDict_SetItem(__pyx_v_filtdict, __pyx_n_s_complevel, __pyx_t_1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3484; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItem(__pyx_v_filtdict, __pyx_n_s_complevel, __pyx_t_1) < 0)) __PYX_ERR(0, 3494, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3482
+ /* "netCDF4/_netCDF4.pyx":3492
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if ideflate: # <<<<<<<<<<<<<<
@@ -33823,7 +33698,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3485
+ /* "netCDF4/_netCDF4.pyx":3495
* filtdict['zlib']=True
* filtdict['complevel']=ideflate_level
* if ishuffle: # <<<<<<<<<<<<<<
@@ -33833,16 +33708,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
__pyx_t_3 = (__pyx_v_ishuffle != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3486
+ /* "netCDF4/_netCDF4.pyx":3496
* filtdict['complevel']=ideflate_level
* if ishuffle:
* filtdict['shuffle']=True # <<<<<<<<<<<<<<
* if ifletcher32:
* filtdict['fletcher32']=True
*/
- if (unlikely(PyDict_SetItem(__pyx_v_filtdict, __pyx_n_s_shuffle, Py_True) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItem(__pyx_v_filtdict, __pyx_n_s_shuffle, Py_True) < 0)) __PYX_ERR(0, 3496, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3485
+ /* "netCDF4/_netCDF4.pyx":3495
* filtdict['zlib']=True
* filtdict['complevel']=ideflate_level
* if ishuffle: # <<<<<<<<<<<<<<
@@ -33851,7 +33726,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3487
+ /* "netCDF4/_netCDF4.pyx":3497
* if ishuffle:
* filtdict['shuffle']=True
* if ifletcher32: # <<<<<<<<<<<<<<
@@ -33861,16 +33736,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
__pyx_t_3 = (__pyx_v_ifletcher32 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3488
+ /* "netCDF4/_netCDF4.pyx":3498
* filtdict['shuffle']=True
* if ifletcher32:
* filtdict['fletcher32']=True # <<<<<<<<<<<<<<
* return filtdict
*
*/
- if (unlikely(PyDict_SetItem(__pyx_v_filtdict, __pyx_n_s_fletcher32, Py_True) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3488; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItem(__pyx_v_filtdict, __pyx_n_s_fletcher32, Py_True) < 0)) __PYX_ERR(0, 3498, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3487
+ /* "netCDF4/_netCDF4.pyx":3497
* if ishuffle:
* filtdict['shuffle']=True
* if ifletcher32: # <<<<<<<<<<<<<<
@@ -33879,7 +33754,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
*/
}
- /* "netCDF4/_netCDF4.pyx":3489
+ /* "netCDF4/_netCDF4.pyx":3499
* if ifletcher32:
* filtdict['fletcher32']=True
* return filtdict # <<<<<<<<<<<<<<
@@ -33891,7 +33766,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
__pyx_r = __pyx_v_filtdict;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3466
+ /* "netCDF4/_netCDF4.pyx":3476
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def filters(self): # <<<<<<<<<<<<<<
@@ -33912,7 +33787,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_26filters(struct __pyx_ob
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3491
+/* "netCDF4/_netCDF4.pyx":3501
* return filtdict
*
* def endian(self): # <<<<<<<<<<<<<<
@@ -33944,34 +33819,31 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
int __pyx_t_3;
char *__pyx_t_4;
PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("endian", 0);
- /* "netCDF4/_netCDF4.pyx":3497
+ /* "netCDF4/_netCDF4.pyx":3507
* return endian-ness (`little,big,native`) of variable (as stored in HDF5 file)."""
* cdef int ierr, iendian
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: # <<<<<<<<<<<<<<
* return 'native'
* with nogil:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4_CLASSIC, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4_CLASSIC, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3507, __pyx_L1_error)
if (__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3507, __pyx_L1_error)
__pyx_t_2 = __pyx_t_3;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3498
+ /* "netCDF4/_netCDF4.pyx":3508
* cdef int ierr, iendian
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']:
* return 'native' # <<<<<<<<<<<<<<
@@ -33983,7 +33855,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
__pyx_r = __pyx_n_s_native;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3497
+ /* "netCDF4/_netCDF4.pyx":3507
* return endian-ness (`little,big,native`) of variable (as stored in HDF5 file)."""
* cdef int ierr, iendian
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: # <<<<<<<<<<<<<<
@@ -33992,7 +33864,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
*/
}
- /* "netCDF4/_netCDF4.pyx":3499
+ /* "netCDF4/_netCDF4.pyx":3509
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']:
* return 'native'
* with nogil: # <<<<<<<<<<<<<<
@@ -34006,7 +33878,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3500
+ /* "netCDF4/_netCDF4.pyx":3510
* return 'native'
* with nogil:
* ierr = nc_inq_var_endian(self._grpid, self._varid, &iendian) # <<<<<<<<<<<<<<
@@ -34016,7 +33888,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
__pyx_v_ierr = nc_inq_var_endian(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_iendian));
}
- /* "netCDF4/_netCDF4.pyx":3499
+ /* "netCDF4/_netCDF4.pyx":3509
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']:
* return 'native'
* with nogil: # <<<<<<<<<<<<<<
@@ -34034,7 +33906,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
}
}
- /* "netCDF4/_netCDF4.pyx":3501
+ /* "netCDF4/_netCDF4.pyx":3511
* with nogil:
* ierr = nc_inq_var_endian(self._grpid, self._varid, &iendian)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -34044,7 +33916,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3502
+ /* "netCDF4/_netCDF4.pyx":3512
* ierr = nc_inq_var_endian(self._grpid, self._varid, &iendian)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -34052,22 +33924,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
* return 'little'
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3512, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3501
+ /* "netCDF4/_netCDF4.pyx":3511
* with nogil:
* ierr = nc_inq_var_endian(self._grpid, self._varid, &iendian)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -34076,7 +33948,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
*/
}
- /* "netCDF4/_netCDF4.pyx":3503
+ /* "netCDF4/_netCDF4.pyx":3513
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if iendian == NC_ENDIAN_LITTLE: # <<<<<<<<<<<<<<
@@ -34086,7 +33958,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
switch (__pyx_v_iendian) {
case NC_ENDIAN_LITTLE:
- /* "netCDF4/_netCDF4.pyx":3504
+ /* "netCDF4/_netCDF4.pyx":3514
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if iendian == NC_ENDIAN_LITTLE:
* return 'little' # <<<<<<<<<<<<<<
@@ -34098,7 +33970,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
__pyx_r = __pyx_n_s_little;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3503
+ /* "netCDF4/_netCDF4.pyx":3513
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if iendian == NC_ENDIAN_LITTLE: # <<<<<<<<<<<<<<
@@ -34107,7 +33979,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
*/
break;
- /* "netCDF4/_netCDF4.pyx":3505
+ /* "netCDF4/_netCDF4.pyx":3515
* if iendian == NC_ENDIAN_LITTLE:
* return 'little'
* elif iendian == NC_ENDIAN_BIG: # <<<<<<<<<<<<<<
@@ -34116,7 +33988,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
*/
case NC_ENDIAN_BIG:
- /* "netCDF4/_netCDF4.pyx":3506
+ /* "netCDF4/_netCDF4.pyx":3516
* return 'little'
* elif iendian == NC_ENDIAN_BIG:
* return 'big' # <<<<<<<<<<<<<<
@@ -34128,7 +34000,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
__pyx_r = __pyx_n_s_big;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3505
+ /* "netCDF4/_netCDF4.pyx":3515
* if iendian == NC_ENDIAN_LITTLE:
* return 'little'
* elif iendian == NC_ENDIAN_BIG: # <<<<<<<<<<<<<<
@@ -34138,7 +34010,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
break;
default:
- /* "netCDF4/_netCDF4.pyx":3508
+ /* "netCDF4/_netCDF4.pyx":3518
* return 'big'
* else:
* return 'native' # <<<<<<<<<<<<<<
@@ -34152,7 +34024,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
break;
}
- /* "netCDF4/_netCDF4.pyx":3491
+ /* "netCDF4/_netCDF4.pyx":3501
* return filtdict
*
* def endian(self): # <<<<<<<<<<<<<<
@@ -34172,7 +34044,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_28endian(struct __pyx_obj
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3510
+/* "netCDF4/_netCDF4.pyx":3520
* return 'native'
*
* def chunking(self): # <<<<<<<<<<<<<<
@@ -34210,27 +34082,24 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
char *__pyx_t_5;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("chunking", 0);
- /* "netCDF4/_netCDF4.pyx":3520
+ /* "netCDF4/_netCDF4.pyx":3530
* cdef int ierr, icontiguous, ndims
* cdef size_t *chunksizesp
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: return None # <<<<<<<<<<<<<<
* ndims = self.ndim
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_grp, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3530, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4_CLASSIC, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4_CLASSIC, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3530, __pyx_L1_error)
if (__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_NETCDF4, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3530, __pyx_L1_error)
__pyx_t_2 = __pyx_t_3;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -34242,17 +34111,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":3521
+ /* "netCDF4/_netCDF4.pyx":3531
* cdef size_t *chunksizesp
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: return None
* ndims = self.ndim # <<<<<<<<<<<<<<
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* with nogil:
*/
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_self->ndim); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3521; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_self->ndim); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3531, __pyx_L1_error)
__pyx_v_ndims = __pyx_t_4;
- /* "netCDF4/_netCDF4.pyx":3522
+ /* "netCDF4/_netCDF4.pyx":3532
* if self._grp.data_model not in ['NETCDF4_CLASSIC','NETCDF4']: return None
* ndims = self.ndim
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims) # <<<<<<<<<<<<<<
@@ -34261,7 +34130,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
*/
__pyx_v_chunksizesp = ((size_t *)malloc(((sizeof(size_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":3523
+ /* "netCDF4/_netCDF4.pyx":3533
* ndims = self.ndim
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* with nogil: # <<<<<<<<<<<<<<
@@ -34275,7 +34144,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3524
+ /* "netCDF4/_netCDF4.pyx":3534
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* with nogil:
* ierr = nc_inq_var_chunking(self._grpid, self._varid, &icontiguous, chunksizesp) # <<<<<<<<<<<<<<
@@ -34285,7 +34154,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
__pyx_v_ierr = nc_inq_var_chunking(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_icontiguous), __pyx_v_chunksizesp);
}
- /* "netCDF4/_netCDF4.pyx":3523
+ /* "netCDF4/_netCDF4.pyx":3533
* ndims = self.ndim
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* with nogil: # <<<<<<<<<<<<<<
@@ -34303,7 +34172,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
}
}
- /* "netCDF4/_netCDF4.pyx":3525
+ /* "netCDF4/_netCDF4.pyx":3535
* with nogil:
* ierr = nc_inq_var_chunking(self._grpid, self._varid, &icontiguous, chunksizesp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -34313,7 +34182,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3526
+ /* "netCDF4/_netCDF4.pyx":3536
* ierr = nc_inq_var_chunking(self._grpid, self._varid, &icontiguous, chunksizesp)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -34321,22 +34190,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
* for n from 0 <= n < ndims:
*/
__pyx_t_5 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_5, 0, strlen(__pyx_t_5), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3526; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_5, 0, strlen(__pyx_t_5), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3536, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3526; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3536, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3526; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3536, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3526; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3536, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3525
+ /* "netCDF4/_netCDF4.pyx":3535
* with nogil:
* ierr = nc_inq_var_chunking(self._grpid, self._varid, &icontiguous, chunksizesp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -34345,19 +34214,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
*/
}
- /* "netCDF4/_netCDF4.pyx":3527
+ /* "netCDF4/_netCDF4.pyx":3537
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* chunksizes=[] # <<<<<<<<<<<<<<
* for n from 0 <= n < ndims:
* chunksizes.append(chunksizesp[n])
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3537, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_chunksizes = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3528
+ /* "netCDF4/_netCDF4.pyx":3538
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* chunksizes=[]
* for n from 0 <= n < ndims: # <<<<<<<<<<<<<<
@@ -34367,20 +34236,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
__pyx_t_4 = __pyx_v_ndims;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_4; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":3529
+ /* "netCDF4/_netCDF4.pyx":3539
* chunksizes=[]
* for n from 0 <= n < ndims:
* chunksizes.append(chunksizesp[n]) # <<<<<<<<<<<<<<
* free(chunksizesp)
* if icontiguous:
*/
- __pyx_t_1 = __Pyx_PyInt_FromSize_t((__pyx_v_chunksizesp[__pyx_v_n])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_FromSize_t((__pyx_v_chunksizesp[__pyx_v_n])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3539, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_chunksizes, __pyx_t_1); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3529; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_chunksizes, __pyx_t_1); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 3539, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3530
+ /* "netCDF4/_netCDF4.pyx":3540
* for n from 0 <= n < ndims:
* chunksizes.append(chunksizesp[n])
* free(chunksizesp) # <<<<<<<<<<<<<<
@@ -34389,7 +34258,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
*/
free(__pyx_v_chunksizesp);
- /* "netCDF4/_netCDF4.pyx":3531
+ /* "netCDF4/_netCDF4.pyx":3541
* chunksizes.append(chunksizesp[n])
* free(chunksizesp)
* if icontiguous: # <<<<<<<<<<<<<<
@@ -34399,7 +34268,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
__pyx_t_3 = (__pyx_v_icontiguous != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3532
+ /* "netCDF4/_netCDF4.pyx":3542
* free(chunksizesp)
* if icontiguous:
* return 'contiguous' # <<<<<<<<<<<<<<
@@ -34411,7 +34280,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
__pyx_r = __pyx_n_s_contiguous;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3531
+ /* "netCDF4/_netCDF4.pyx":3541
* chunksizes.append(chunksizesp[n])
* free(chunksizesp)
* if icontiguous: # <<<<<<<<<<<<<<
@@ -34420,7 +34289,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
*/
}
- /* "netCDF4/_netCDF4.pyx":3534
+ /* "netCDF4/_netCDF4.pyx":3544
* return 'contiguous'
* else:
* return chunksizes # <<<<<<<<<<<<<<
@@ -34434,7 +34303,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":3510
+ /* "netCDF4/_netCDF4.pyx":3520
* return 'native'
*
* def chunking(self): # <<<<<<<<<<<<<<
@@ -34455,7 +34324,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_30chunking(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3536
+/* "netCDF4/_netCDF4.pyx":3546
* return chunksizes
*
* def get_var_chunk_cache(self): # <<<<<<<<<<<<<<
@@ -34492,12 +34361,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("get_var_chunk_cache", 0);
- /* "netCDF4/_netCDF4.pyx":3546
+ /* "netCDF4/_netCDF4.pyx":3556
* cdef size_t sizep, nelemsp
* cdef float preemptionp
* with nogil: # <<<<<<<<<<<<<<
@@ -34511,7 +34377,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3547
+ /* "netCDF4/_netCDF4.pyx":3557
* cdef float preemptionp
* with nogil:
* ierr = nc_get_var_chunk_cache(self._grpid, self._varid, &sizep, # <<<<<<<<<<<<<<
@@ -34521,7 +34387,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
__pyx_v_ierr = nc_get_var_chunk_cache(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_sizep), (&__pyx_v_nelemsp), (&__pyx_v_preemptionp));
}
- /* "netCDF4/_netCDF4.pyx":3546
+ /* "netCDF4/_netCDF4.pyx":3556
* cdef size_t sizep, nelemsp
* cdef float preemptionp
* with nogil: # <<<<<<<<<<<<<<
@@ -34539,7 +34405,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
}
}
- /* "netCDF4/_netCDF4.pyx":3549
+ /* "netCDF4/_netCDF4.pyx":3559
* ierr = nc_get_var_chunk_cache(self._grpid, self._varid, &sizep,
* &nelemsp, &preemptionp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -34549,7 +34415,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
__pyx_t_1 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3550
+ /* "netCDF4/_netCDF4.pyx":3560
* &nelemsp, &preemptionp)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -34557,22 +34423,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
* return (size,nelems,preemption)
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3550; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3550; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3550; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3550; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3560, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3549
+ /* "netCDF4/_netCDF4.pyx":3559
* ierr = nc_get_var_chunk_cache(self._grpid, self._varid, &sizep,
* &nelemsp, &preemptionp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -34581,7 +34447,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
*/
}
- /* "netCDF4/_netCDF4.pyx":3551
+ /* "netCDF4/_netCDF4.pyx":3561
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* size = sizep; nelems = nelemsp; preemption = preemptionp # <<<<<<<<<<<<<<
@@ -34590,12 +34456,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
*/
__pyx_v_size = __pyx_v_sizep;
__pyx_v_nelems = __pyx_v_nelemsp;
- __pyx_t_3 = PyFloat_FromDouble(__pyx_v_preemptionp); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyFloat_FromDouble(__pyx_v_preemptionp); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3561, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_preemption = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3552
+ /* "netCDF4/_netCDF4.pyx":3562
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* size = sizep; nelems = nelemsp; preemption = preemptionp
* return (size,nelems,preemption) # <<<<<<<<<<<<<<
@@ -34603,11 +34469,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
* def set_var_chunk_cache(self,size=None,nelems=None,preemption=None):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_FromSize_t(__pyx_v_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3562, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyInt_FromSize_t(__pyx_v_nelems); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_FromSize_t(__pyx_v_nelems); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3562, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3562, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3);
@@ -34622,7 +34488,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
__pyx_t_5 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3536
+ /* "netCDF4/_netCDF4.pyx":3546
* return chunksizes
*
* def get_var_chunk_cache(self): # <<<<<<<<<<<<<<
@@ -34644,7 +34510,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_32get_var_chunk_cache(str
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3554
+/* "netCDF4/_netCDF4.pyx":3564
* return (size,nelems,preemption)
*
* def set_var_chunk_cache(self,size=None,nelems=None,preemption=None): # <<<<<<<<<<<<<<
@@ -34659,9 +34525,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_35set_var_chunk_cache(PyO
PyObject *__pyx_v_size = 0;
PyObject *__pyx_v_nelems = 0;
PyObject *__pyx_v_preemption = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("set_var_chunk_cache (wrapper)", 0);
@@ -34700,7 +34563,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_35set_var_chunk_cache(PyO
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_var_chunk_cache") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3554; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_var_chunk_cache") < 0)) __PYX_ERR(0, 3564, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -34717,7 +34580,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_35set_var_chunk_cache(PyO
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("set_var_chunk_cache", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3554; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("set_var_chunk_cache", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3564, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Variable.set_var_chunk_cache", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -34751,19 +34614,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
size_t __pyx_t_9;
float __pyx_t_10;
char *__pyx_t_11;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_var_chunk_cache", 0);
- /* "netCDF4/_netCDF4.pyx":3565
+ /* "netCDF4/_netCDF4.pyx":3575
* cdef float preemptionp
* # reset chunk cache size, leave other parameters unchanged.
* size_orig, nelems_orig, preemption_orig = self.get_var_chunk_cache() # <<<<<<<<<<<<<<
* if size is not None:
* sizep = size
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_var_chunk_cache); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_var_chunk_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3575, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -34776,10 +34636,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3575, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3575, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -34793,7 +34653,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
if (unlikely(size != 3)) {
if (size > 3) __Pyx_RaiseTooManyValuesError(3);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3575, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -34809,17 +34669,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
#else
- __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3575, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3575, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3575, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3575, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_6 = Py_TYPE(__pyx_t_5)->tp_iternext;
@@ -34829,7 +34689,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
__Pyx_GOTREF(__pyx_t_3);
index = 2; __pyx_t_4 = __pyx_t_6(__pyx_t_5); if (unlikely(!__pyx_t_4)) goto __pyx_L3_unpacking_failed;
__Pyx_GOTREF(__pyx_t_4);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_6(__pyx_t_5), 3) < 0) __PYX_ERR(0, 3575, __pyx_L1_error)
__pyx_t_6 = NULL;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
goto __pyx_L4_unpacking_done;
@@ -34837,7 +34697,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3575, __pyx_L1_error)
__pyx_L4_unpacking_done:;
}
__pyx_v_size_orig = __pyx_t_2;
@@ -34847,7 +34707,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
__pyx_v_preemption_orig = __pyx_t_4;
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3566
+ /* "netCDF4/_netCDF4.pyx":3576
* # reset chunk cache size, leave other parameters unchanged.
* size_orig, nelems_orig, preemption_orig = self.get_var_chunk_cache()
* if size is not None: # <<<<<<<<<<<<<<
@@ -34858,17 +34718,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
__pyx_t_8 = (__pyx_t_7 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3567
+ /* "netCDF4/_netCDF4.pyx":3577
* size_orig, nelems_orig, preemption_orig = self.get_var_chunk_cache()
* if size is not None:
* sizep = size # <<<<<<<<<<<<<<
* else:
* sizep = size_orig
*/
- __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_size); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_size); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3577, __pyx_L1_error)
__pyx_v_sizep = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":3566
+ /* "netCDF4/_netCDF4.pyx":3576
* # reset chunk cache size, leave other parameters unchanged.
* size_orig, nelems_orig, preemption_orig = self.get_var_chunk_cache()
* if size is not None: # <<<<<<<<<<<<<<
@@ -34878,7 +34738,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
goto __pyx_L5;
}
- /* "netCDF4/_netCDF4.pyx":3569
+ /* "netCDF4/_netCDF4.pyx":3579
* sizep = size
* else:
* sizep = size_orig # <<<<<<<<<<<<<<
@@ -34886,12 +34746,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
* nelemsp = nelems
*/
/*else*/ {
- __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_size_orig); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3569; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_size_orig); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3579, __pyx_L1_error)
__pyx_v_sizep = __pyx_t_9;
}
__pyx_L5:;
- /* "netCDF4/_netCDF4.pyx":3570
+ /* "netCDF4/_netCDF4.pyx":3580
* else:
* sizep = size_orig
* if nelems is not None: # <<<<<<<<<<<<<<
@@ -34902,17 +34762,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
__pyx_t_7 = (__pyx_t_8 != 0);
if (__pyx_t_7) {
- /* "netCDF4/_netCDF4.pyx":3571
+ /* "netCDF4/_netCDF4.pyx":3581
* sizep = size_orig
* if nelems is not None:
* nelemsp = nelems # <<<<<<<<<<<<<<
* else:
* nelemsp = nelems_orig
*/
- __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_nelems); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3571; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_nelems); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3581, __pyx_L1_error)
__pyx_v_nelemsp = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":3570
+ /* "netCDF4/_netCDF4.pyx":3580
* else:
* sizep = size_orig
* if nelems is not None: # <<<<<<<<<<<<<<
@@ -34922,7 +34782,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
goto __pyx_L6;
}
- /* "netCDF4/_netCDF4.pyx":3573
+ /* "netCDF4/_netCDF4.pyx":3583
* nelemsp = nelems
* else:
* nelemsp = nelems_orig # <<<<<<<<<<<<<<
@@ -34930,12 +34790,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
* preemptionp = preemption
*/
/*else*/ {
- __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_nelems_orig); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3573; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_size_t(__pyx_v_nelems_orig); if (unlikely((__pyx_t_9 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3583, __pyx_L1_error)
__pyx_v_nelemsp = __pyx_t_9;
}
__pyx_L6:;
- /* "netCDF4/_netCDF4.pyx":3574
+ /* "netCDF4/_netCDF4.pyx":3584
* else:
* nelemsp = nelems_orig
* if preemption is not None: # <<<<<<<<<<<<<<
@@ -34946,17 +34806,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
__pyx_t_8 = (__pyx_t_7 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3575
+ /* "netCDF4/_netCDF4.pyx":3585
* nelemsp = nelems_orig
* if preemption is not None:
* preemptionp = preemption # <<<<<<<<<<<<<<
* else:
* preemptionp = preemption_orig
*/
- __pyx_t_10 = __pyx_PyFloat_AsFloat(__pyx_v_preemption); if (unlikely((__pyx_t_10 == (float)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3575; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __pyx_PyFloat_AsFloat(__pyx_v_preemption); if (unlikely((__pyx_t_10 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3585, __pyx_L1_error)
__pyx_v_preemptionp = __pyx_t_10;
- /* "netCDF4/_netCDF4.pyx":3574
+ /* "netCDF4/_netCDF4.pyx":3584
* else:
* nelemsp = nelems_orig
* if preemption is not None: # <<<<<<<<<<<<<<
@@ -34966,7 +34826,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
goto __pyx_L7;
}
- /* "netCDF4/_netCDF4.pyx":3577
+ /* "netCDF4/_netCDF4.pyx":3587
* preemptionp = preemption
* else:
* preemptionp = preemption_orig # <<<<<<<<<<<<<<
@@ -34974,12 +34834,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
* nelemsp, preemptionp)
*/
/*else*/ {
- __pyx_t_10 = __pyx_PyFloat_AsFloat(__pyx_v_preemption_orig); if (unlikely((__pyx_t_10 == (float)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3577; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __pyx_PyFloat_AsFloat(__pyx_v_preemption_orig); if (unlikely((__pyx_t_10 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3587, __pyx_L1_error)
__pyx_v_preemptionp = __pyx_t_10;
}
__pyx_L7:;
- /* "netCDF4/_netCDF4.pyx":3578
+ /* "netCDF4/_netCDF4.pyx":3588
* else:
* preemptionp = preemption_orig
* ierr = nc_set_var_chunk_cache(self._grpid, self._varid, sizep, # <<<<<<<<<<<<<<
@@ -34988,7 +34848,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
*/
__pyx_v_ierr = nc_set_var_chunk_cache(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_sizep, __pyx_v_nelemsp, __pyx_v_preemptionp);
- /* "netCDF4/_netCDF4.pyx":3580
+ /* "netCDF4/_netCDF4.pyx":3590
* ierr = nc_set_var_chunk_cache(self._grpid, self._varid, sizep,
* nelemsp, preemptionp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -34998,7 +34858,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
__pyx_t_8 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3581
+ /* "netCDF4/_netCDF4.pyx":3591
* nelemsp, preemptionp)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -35006,22 +34866,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
* def __delattr__(self,name):
*/
__pyx_t_11 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_11, 0, strlen(__pyx_t_11), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_11, 0, strlen(__pyx_t_11), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3591, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3580
+ /* "netCDF4/_netCDF4.pyx":3590
* ierr = nc_set_var_chunk_cache(self._grpid, self._varid, sizep,
* nelemsp, preemptionp)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -35030,7 +34890,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
*/
}
- /* "netCDF4/_netCDF4.pyx":3554
+ /* "netCDF4/_netCDF4.pyx":3564
* return (size,nelems,preemption)
*
* def set_var_chunk_cache(self,size=None,nelems=None,preemption=None): # <<<<<<<<<<<<<<
@@ -35058,7 +34918,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_34set_var_chunk_cache(str
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3583
+/* "netCDF4/_netCDF4.pyx":3593
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def __delattr__(self,name): # <<<<<<<<<<<<<<
@@ -35088,33 +34948,30 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_36__delattr__(struct __pyx_obj_
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__delattr__", 0);
- /* "netCDF4/_netCDF4.pyx":3585
+ /* "netCDF4/_netCDF4.pyx":3595
* def __delattr__(self,name):
* # if it's a netCDF attribute, remove it
* if name not in _private_atts: # <<<<<<<<<<<<<<
* self.delncattr(name)
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3585; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3595, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3585; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3595, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3586
+ /* "netCDF4/_netCDF4.pyx":3596
* # if it's a netCDF attribute, remove it
* if name not in _private_atts:
* self.delncattr(name) # <<<<<<<<<<<<<<
* else:
* raise AttributeError(
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_delncattr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3586; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_delncattr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3596, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -35127,23 +34984,23 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_36__delattr__(struct __pyx_obj_
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_name); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3586; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3596, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3586; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3596, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_name);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3586; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3596, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3585
+ /* "netCDF4/_netCDF4.pyx":3595
* def __delattr__(self,name):
* # if it's a netCDF attribute, remove it
* if name not in _private_atts: # <<<<<<<<<<<<<<
@@ -35153,7 +35010,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_36__delattr__(struct __pyx_obj_
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":3588
+ /* "netCDF4/_netCDF4.pyx":3598
* self.delncattr(name)
* else:
* raise AttributeError( # <<<<<<<<<<<<<<
@@ -35162,19 +35019,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_36__delattr__(struct __pyx_obj_
*/
/*else*/ {
- /* "netCDF4/_netCDF4.pyx":3589
+ /* "netCDF4/_netCDF4.pyx":3599
* else:
* raise AttributeError(
* "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead." % (name, tuple(_private_atts))) # <<<<<<<<<<<<<<
*
* def __setattr__(self,name,value):
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
@@ -35182,32 +35039,32 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_36__delattr__(struct __pyx_obj_
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_is_one_of_the_reserved_attrib, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_is_one_of_the_reserved_attrib, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3588
+ /* "netCDF4/_netCDF4.pyx":3598
* self.delncattr(name)
* else:
* raise AttributeError( # <<<<<<<<<<<<<<
* "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead." % (name, tuple(_private_atts)))
*
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3588; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3598, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3588; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3598, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3588; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3598, __pyx_L1_error)
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":3583
+ /* "netCDF4/_netCDF4.pyx":3593
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def __delattr__(self,name): # <<<<<<<<<<<<<<
@@ -35230,7 +35087,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_36__delattr__(struct __pyx_obj_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3591
+/* "netCDF4/_netCDF4.pyx":3601
* "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead." % (name, tuple(_private_atts)))
*
* def __setattr__(self,name,value): # <<<<<<<<<<<<<<
@@ -35262,265 +35119,417 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_38__setattr__(struct __pyx_obj_
PyObject *__pyx_t_5 = NULL;
Py_ssize_t __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setattr__", 0);
__Pyx_INCREF(__pyx_v_value);
- /* "netCDF4/_netCDF4.pyx":3594
+ /* "netCDF4/_netCDF4.pyx":3604
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name not in _private_atts: # <<<<<<<<<<<<<<
* # if setting _FillValue or missing_value, make sure value
- * # has same type as variable.
+ * # has same type and byte order as variable.
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3604, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_1, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3604, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3597
+ /* "netCDF4/_netCDF4.pyx":3607
* # if setting _FillValue or missing_value, make sure value
- * # has same type as variable.
+ * # has same type and byte order as variable.
* if name == '_FillValue': # <<<<<<<<<<<<<<
* msg='_FillValue attribute must be set when variable is '+\
* 'created (using fill_value keyword to createVariable)'
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_FillValue, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3597; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_FillValue, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3607, __pyx_L1_error)
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3598
- * # has same type as variable.
+ /* "netCDF4/_netCDF4.pyx":3608
+ * # has same type and byte order as variable.
* if name == '_FillValue':
* msg='_FillValue attribute must be set when variable is '+\ # <<<<<<<<<<<<<<
* 'created (using fill_value keyword to createVariable)'
* raise AttributeError(msg)
*/
- __pyx_t_1 = PyNumber_Add(__pyx_kp_s_FillValue_attribute_must_be_set, __pyx_kp_s_created_using_fill_value_keyword); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3598; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_kp_s_FillValue_attribute_must_be_set, __pyx_kp_s_created_using_fill_value_keyword); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_msg = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3600
+ /* "netCDF4/_netCDF4.pyx":3610
* msg='_FillValue attribute must be set when variable is '+\
* 'created (using fill_value keyword to createVariable)'
* raise AttributeError(msg) # <<<<<<<<<<<<<<
* #if self._isprimitive:
* # value = numpy.array(value, self.dtype)
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3600; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_msg);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3600; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3600; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3610, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3597
+ /* "netCDF4/_netCDF4.pyx":3607
* # if setting _FillValue or missing_value, make sure value
- * # has same type as variable.
+ * # has same type and byte order as variable.
* if name == '_FillValue': # <<<<<<<<<<<<<<
* msg='_FillValue attribute must be set when variable is '+\
* 'created (using fill_value keyword to createVariable)'
*/
}
- /* "netCDF4/_netCDF4.pyx":3607
+ /* "netCDF4/_netCDF4.pyx":3617
* # "VLEN or compound variable"
* # raise AttributeError(msg)
* elif name == 'missing_value' and self._isprimitive: # <<<<<<<<<<<<<<
- * value = numpy.array(value, self.dtype)
- * self.setncattr(name, value)
+ * if (is_native_little and self.endian() == 'big') or\
+ * (is_native_big and self.endian() == 'little'):
*/
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_missing_value, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_missing_value, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3617, __pyx_L1_error)
if (__pyx_t_2) {
} else {
__pyx_t_3 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3617, __pyx_L1_error)
__pyx_t_3 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3608
+ /* "netCDF4/_netCDF4.pyx":3618
* # raise AttributeError(msg)
* elif name == 'missing_value' and self._isprimitive:
- * value = numpy.array(value, self.dtype) # <<<<<<<<<<<<<<
- * self.setncattr(name, value)
- * elif not name.endswith('__'):
+ * if (is_native_little and self.endian() == 'big') or\ # <<<<<<<<<<<<<<
+ * (is_native_big and self.endian() == 'little'):
+ * value = numpy.array(value, self.dtype).byteswap(True)
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3618, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3618, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (!__pyx_t_2) {
+ goto __pyx_L9_next_or;
+ } else {
+ }
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3618, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_5 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_1, function);
+ }
+ }
+ if (__pyx_t_5) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3618, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else {
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3618, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = NULL;
- __pyx_t_6 = 0;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_1)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_1);
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_big, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3618, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (!__pyx_t_2) {
+ } else {
+ __pyx_t_3 = __pyx_t_2;
+ goto __pyx_L8_bool_binop_done;
+ }
+ __pyx_L9_next_or:;
+
+ /* "netCDF4/_netCDF4.pyx":3619
+ * elif name == 'missing_value' and self._isprimitive:
+ * if (is_native_little and self.endian() == 'big') or\
+ * (is_native_big and self.endian() == 'little'): # <<<<<<<<<<<<<<
+ * value = numpy.array(value, self.dtype).byteswap(True)
+ * else:
+ */
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3619, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3619, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_3 = __pyx_t_2;
+ goto __pyx_L8_bool_binop_done;
+ }
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3619, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_5 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+ __Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
- __pyx_t_6 = 1;
+ __Pyx_DECREF_SET(__pyx_t_1, function);
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (__pyx_t_1) {
- __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
+ if (__pyx_t_5) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3619, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ } else {
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3619, __pyx_L1_error)
}
- __Pyx_INCREF(__pyx_v_value);
- __Pyx_GIVEREF(__pyx_v_value);
- PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_value);
- __Pyx_INCREF(__pyx_v_self->dtype);
- __Pyx_GIVEREF(__pyx_v_self->dtype);
- PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_self->dtype);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_4);
- __pyx_t_4 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_little, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3619, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_3 = __pyx_t_2;
+ __pyx_L8_bool_binop_done:;
- /* "netCDF4/_netCDF4.pyx":3607
+ /* "netCDF4/_netCDF4.pyx":3618
+ * # raise AttributeError(msg)
+ * elif name == 'missing_value' and self._isprimitive:
+ * if (is_native_little and self.endian() == 'big') or\ # <<<<<<<<<<<<<<
+ * (is_native_big and self.endian() == 'little'):
+ * value = numpy.array(value, self.dtype).byteswap(True)
+ */
+ if (__pyx_t_3) {
+
+ /* "netCDF4/_netCDF4.pyx":3620
+ * if (is_native_little and self.endian() == 'big') or\
+ * (is_native_big and self.endian() == 'little'):
+ * value = numpy.array(value, self.dtype).byteswap(True) # <<<<<<<<<<<<<<
+ * else:
+ * value = numpy.array(value, self.dtype)
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3620, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3620, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_1)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_1);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3620, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (__pyx_t_1) {
+ __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
+ }
+ __Pyx_INCREF(__pyx_v_value);
+ __Pyx_GIVEREF(__pyx_v_value);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_v_value);
+ __Pyx_INCREF(__pyx_v_self->dtype);
+ __Pyx_GIVEREF(__pyx_v_self->dtype);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_self->dtype);
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3620, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3620, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3620, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_4);
+ __pyx_t_4 = 0;
+
+ /* "netCDF4/_netCDF4.pyx":3618
+ * # raise AttributeError(msg)
+ * elif name == 'missing_value' and self._isprimitive:
+ * if (is_native_little and self.endian() == 'big') or\ # <<<<<<<<<<<<<<
+ * (is_native_big and self.endian() == 'little'):
+ * value = numpy.array(value, self.dtype).byteswap(True)
+ */
+ goto __pyx_L7;
+ }
+
+ /* "netCDF4/_netCDF4.pyx":3622
+ * value = numpy.array(value, self.dtype).byteswap(True)
+ * else:
+ * value = numpy.array(value, self.dtype) # <<<<<<<<<<<<<<
+ * self.setncattr(name, value)
+ * elif not name.endswith('__'):
+ */
+ /*else*/ {
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3622, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3622, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ __pyx_t_6 = 0;
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
+ __pyx_t_6 = 1;
+ }
+ }
+ __pyx_t_1 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3622, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (__pyx_t_5) {
+ __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ }
+ __Pyx_INCREF(__pyx_v_value);
+ __Pyx_GIVEREF(__pyx_v_value);
+ PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_6, __pyx_v_value);
+ __Pyx_INCREF(__pyx_v_self->dtype);
+ __Pyx_GIVEREF(__pyx_v_self->dtype);
+ PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_6, __pyx_v_self->dtype);
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3622, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF_SET(__pyx_v_value, __pyx_t_4);
+ __pyx_t_4 = 0;
+ }
+ __pyx_L7:;
+
+ /* "netCDF4/_netCDF4.pyx":3617
* # "VLEN or compound variable"
* # raise AttributeError(msg)
* elif name == 'missing_value' and self._isprimitive: # <<<<<<<<<<<<<<
- * value = numpy.array(value, self.dtype)
- * self.setncattr(name, value)
+ * if (is_native_little and self.endian() == 'big') or\
+ * (is_native_big and self.endian() == 'little'):
*/
}
- /* "netCDF4/_netCDF4.pyx":3609
- * elif name == 'missing_value' and self._isprimitive:
- * value = numpy.array(value, self.dtype)
+ /* "netCDF4/_netCDF4.pyx":3623
+ * else:
+ * value = numpy.array(value, self.dtype)
* self.setncattr(name, value) # <<<<<<<<<<<<<<
* elif not name.endswith('__'):
* if hasattr(self,name):
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setncattr); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = NULL;
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_setncattr); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_1 = NULL;
__pyx_t_6 = 0;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_7)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_7);
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_7);
+ if (likely(__pyx_t_1)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
__pyx_t_6 = 1;
}
}
- __pyx_t_1 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- if (__pyx_t_7) {
- __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __pyx_t_5 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ if (__pyx_t_1) {
+ __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __pyx_t_1 = NULL;
}
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
- PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_6, __pyx_v_name);
+ PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_6, __pyx_v_name);
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
- PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_6, __pyx_v_value);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_6, __pyx_v_value);
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3623, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3594
+ /* "netCDF4/_netCDF4.pyx":3604
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name not in _private_atts: # <<<<<<<<<<<<<<
* # if setting _FillValue or missing_value, make sure value
- * # has same type as variable.
+ * # has same type and byte order as variable.
*/
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":3610
- * value = numpy.array(value, self.dtype)
+ /* "netCDF4/_netCDF4.pyx":3624
+ * value = numpy.array(value, self.dtype)
* self.setncattr(name, value)
* elif not name.endswith('__'): # <<<<<<<<<<<<<<
* if hasattr(self,name):
* raise AttributeError(
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3624, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3624, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3624, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_2 = ((!__pyx_t_3) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3611
+ /* "netCDF4/_netCDF4.pyx":3625
* self.setncattr(name, value)
* elif not name.endswith('__'):
* if hasattr(self,name): # <<<<<<<<<<<<<<
* raise AttributeError(
* "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead." % (name, tuple(_private_atts)))
*/
- __pyx_t_2 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_v_name); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_v_name); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 3625, __pyx_L1_error)
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3613
+ /* "netCDF4/_netCDF4.pyx":3627
* if hasattr(self,name):
* raise AttributeError(
* "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead." % (name, tuple(_private_atts))) # <<<<<<<<<<<<<<
* else:
* self.__dict__[name]=value
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PySequence_Tuple(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3627, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_4 = PySequence_Tuple(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3627, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3627, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
- PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_name);
+ PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v_name);
__Pyx_GIVEREF(__pyx_t_4);
- PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_is_one_of_the_reserved_attrib_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_s_is_one_of_the_reserved_attrib_2, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3627, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3612
+ /* "netCDF4/_netCDF4.pyx":3626
* elif not name.endswith('__'):
* if hasattr(self,name):
* raise AttributeError( # <<<<<<<<<<<<<<
* "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead." % (name, tuple(_private_atts)))
* else:
*/
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3626, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_4);
- PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3626, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3626, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3611
+ /* "netCDF4/_netCDF4.pyx":3625
* self.setncattr(name, value)
* elif not name.endswith('__'):
* if hasattr(self,name): # <<<<<<<<<<<<<<
@@ -35529,7 +35538,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_38__setattr__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3615
+ /* "netCDF4/_netCDF4.pyx":3629
* "'%s' is one of the reserved attributes %s, cannot rebind. Use setncattr instead." % (name, tuple(_private_atts)))
* else:
* self.__dict__[name]=value # <<<<<<<<<<<<<<
@@ -35537,14 +35546,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_38__setattr__(struct __pyx_obj_
* def __getattr__(self,name):
*/
/*else*/ {
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dict); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3615; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3629, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- if (unlikely(PyObject_SetItem(__pyx_t_4, __pyx_v_name, __pyx_v_value) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3615; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_4, __pyx_v_name, __pyx_v_value) < 0)) __PYX_ERR(0, 3629, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3610
- * value = numpy.array(value, self.dtype)
+ /* "netCDF4/_netCDF4.pyx":3624
+ * value = numpy.array(value, self.dtype)
* self.setncattr(name, value)
* elif not name.endswith('__'): # <<<<<<<<<<<<<<
* if hasattr(self,name):
@@ -35553,7 +35562,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_38__setattr__(struct __pyx_obj_
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":3591
+ /* "netCDF4/_netCDF4.pyx":3601
* "'%s' is one of the reserved attributes %s, cannot delete. Use delncattr instead." % (name, tuple(_private_atts)))
*
* def __setattr__(self,name,value): # <<<<<<<<<<<<<<
@@ -35578,7 +35587,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_38__setattr__(struct __pyx_obj_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3617
+/* "netCDF4/_netCDF4.pyx":3631
* self.__dict__[name]=value
*
* def __getattr__(self,name): # <<<<<<<<<<<<<<
@@ -35615,60 +35624,57 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getattr__", 0);
__Pyx_INCREF(__pyx_v_name);
- /* "netCDF4/_netCDF4.pyx":3620
+ /* "netCDF4/_netCDF4.pyx":3634
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<<
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__':
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_startswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3634, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_4) {
} else {
__pyx_t_1 = __pyx_t_4;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_name, __pyx_n_s_endswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 3634, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_1 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3622
+ /* "netCDF4/_netCDF4.pyx":3636
* if name.startswith('__') and name.endswith('__'):
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__': # <<<<<<<<<<<<<<
* names = self.ncattrs()
* values = []
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_dict, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3622; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_dict, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3636, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3623
+ /* "netCDF4/_netCDF4.pyx":3637
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__':
* names = self.ncattrs() # <<<<<<<<<<<<<<
* values = []
* for name in names:
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3637, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -35681,29 +35687,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
}
}
if (__pyx_t_5) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3637, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3637, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_names = __pyx_t_2;
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3624
+ /* "netCDF4/_netCDF4.pyx":3638
* if name == '__dict__':
* names = self.ncattrs()
* values = [] # <<<<<<<<<<<<<<
* for name in names:
* values.append(_get_att(self._grp, self._varid, name))
*/
- __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3624; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3638, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_v_values = ((PyObject*)__pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3625
+ /* "netCDF4/_netCDF4.pyx":3639
* names = self.ncattrs()
* values = []
* for name in names: # <<<<<<<<<<<<<<
@@ -35714,26 +35720,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
__pyx_t_2 = __pyx_v_names; __Pyx_INCREF(__pyx_t_2); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_names); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_names); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3639, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3639, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_7)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3639, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3639, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6); __Pyx_INCREF(__pyx_t_3); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3639, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_2, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3639, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
}
@@ -35743,7 +35749,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3639, __pyx_L1_error)
}
break;
}
@@ -35752,7 +35758,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
__Pyx_DECREF_SET(__pyx_v_name, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3626
+ /* "netCDF4/_netCDF4.pyx":3640
* values = []
* for name in names:
* values.append(_get_att(self._grp, self._varid, name)) # <<<<<<<<<<<<<<
@@ -35761,13 +35767,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
*/
__pyx_t_3 = __pyx_v_self->_grp;
__Pyx_INCREF(__pyx_t_3);
- __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__get_att(__pyx_t_3, __pyx_v_self->_varid, __pyx_v_name); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3626; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__get_att(__pyx_t_3, __pyx_v_self->_varid, __pyx_v_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3640, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_values, __pyx_t_5); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3626; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_values, __pyx_t_5); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 3640, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3625
+ /* "netCDF4/_netCDF4.pyx":3639
* names = self.ncattrs()
* values = []
* for name in names: # <<<<<<<<<<<<<<
@@ -35777,7 +35783,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3627
+ /* "netCDF4/_netCDF4.pyx":3641
* for name in names:
* values.append(_get_att(self._grp, self._varid, name))
* return OrderedDict(zip(names,values)) # <<<<<<<<<<<<<<
@@ -35785,9 +35791,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
* raise AttributeError
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3641, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3641, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_10 = NULL;
__pyx_t_6 = 0;
@@ -35801,7 +35807,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
__pyx_t_6 = 1;
}
}
- __pyx_t_11 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3641, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
if (__pyx_t_10) {
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_10); __pyx_t_10 = NULL;
@@ -35812,7 +35818,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
__Pyx_INCREF(__pyx_v_values);
__Pyx_GIVEREF(__pyx_v_values);
PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_6, __pyx_v_values);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3641, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -35827,17 +35833,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
}
}
if (!__pyx_t_9) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3641, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3641, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_11, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3641, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
}
@@ -35846,7 +35852,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
__pyx_t_2 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3622
+ /* "netCDF4/_netCDF4.pyx":3636
* if name.startswith('__') and name.endswith('__'):
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__': # <<<<<<<<<<<<<<
@@ -35855,7 +35861,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":3629
+ /* "netCDF4/_netCDF4.pyx":3643
* return OrderedDict(zip(names,values))
* else:
* raise AttributeError # <<<<<<<<<<<<<<
@@ -35864,10 +35870,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
*/
/*else*/ {
__Pyx_Raise(__pyx_builtin_AttributeError, 0, 0, 0);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3629; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3643, __pyx_L1_error)
}
- /* "netCDF4/_netCDF4.pyx":3620
+ /* "netCDF4/_netCDF4.pyx":3634
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<<
@@ -35876,21 +35882,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":3630
+ /* "netCDF4/_netCDF4.pyx":3644
* else:
* raise AttributeError
* elif name in _private_atts: # <<<<<<<<<<<<<<
* return self.__dict__[name]
* else:
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_private_atts); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_name, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3644, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = (__pyx_t_1 != 0);
if (__pyx_t_4) {
- /* "netCDF4/_netCDF4.pyx":3631
+ /* "netCDF4/_netCDF4.pyx":3645
* raise AttributeError
* elif name in _private_atts:
* return self.__dict__[name] # <<<<<<<<<<<<<<
@@ -35898,16 +35904,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
* return self.getncattr(name)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3631; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = PyObject_GetItem(__pyx_t_2, __pyx_v_name); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3631; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = PyObject_GetItem(__pyx_t_2, __pyx_v_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3630
+ /* "netCDF4/_netCDF4.pyx":3644
* else:
* raise AttributeError
* elif name in _private_atts: # <<<<<<<<<<<<<<
@@ -35916,7 +35922,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":3633
+ /* "netCDF4/_netCDF4.pyx":3647
* return self.__dict__[name]
* else:
* return self.getncattr(name) # <<<<<<<<<<<<<<
@@ -35925,7 +35931,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getncattr); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3633; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_getncattr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3647, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_11 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -35938,16 +35944,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
}
}
if (!__pyx_t_11) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_name); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3633; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3647, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3633; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3647, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_11); __pyx_t_11 = NULL;
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_name);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3633; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3647, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
@@ -35957,7 +35963,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":3617
+ /* "netCDF4/_netCDF4.pyx":3631
* self.__dict__[name]=value
*
* def __getattr__(self,name): # <<<<<<<<<<<<<<
@@ -35984,7 +35990,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_40__getattr__(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3635
+/* "netCDF4/_netCDF4.pyx":3649
* return self.getncattr(name)
*
* def renameAttribute(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -35998,9 +36004,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_8Variable_42renameAttribute[] = "\n**`r
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_43renameAttribute(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_oldname = 0;
PyObject *__pyx_v_newname = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("renameAttribute (wrapper)", 0);
@@ -36024,11 +36027,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_43renameAttribute(PyObjec
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_newname)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("renameAttribute", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3635; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameAttribute", 1, 2, 2, 1); __PYX_ERR(0, 3649, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameAttribute") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3635; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "renameAttribute") < 0)) __PYX_ERR(0, 3649, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -36041,7 +36044,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_43renameAttribute(PyObjec
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("renameAttribute", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3635; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("renameAttribute", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3649, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Variable.renameAttribute", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -36065,107 +36068,104 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_42renameAttribute(struct
char *__pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("renameAttribute", 0);
- /* "netCDF4/_netCDF4.pyx":3643
+ /* "netCDF4/_netCDF4.pyx":3657
* cdef char *oldnamec
* cdef char *newnamec
* bytestr = _strencode(oldname) # <<<<<<<<<<<<<<
* oldnamec = bytestr
* bytestr = _strencode(newname)
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_oldname, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_oldname, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3657, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3644
+ /* "netCDF4/_netCDF4.pyx":3658
* cdef char *newnamec
* bytestr = _strencode(oldname)
* oldnamec = bytestr # <<<<<<<<<<<<<<
* bytestr = _strencode(newname)
* newnamec = bytestr
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 3658, __pyx_L1_error)
__pyx_v_oldnamec = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":3645
+ /* "netCDF4/_netCDF4.pyx":3659
* bytestr = _strencode(oldname)
* oldnamec = bytestr
* bytestr = _strencode(newname) # <<<<<<<<<<<<<<
* newnamec = bytestr
* ierr = nc_rename_att(self._grpid, self._varid, oldnamec, newnamec)
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_newname, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_newname, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3659, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF_SET(__pyx_v_bytestr, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3646
+ /* "netCDF4/_netCDF4.pyx":3660
* oldnamec = bytestr
* bytestr = _strencode(newname)
* newnamec = bytestr # <<<<<<<<<<<<<<
* ierr = nc_rename_att(self._grpid, self._varid, oldnamec, newnamec)
* if ierr != NC_NOERR:
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3646; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 3660, __pyx_L1_error)
__pyx_v_newnamec = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":3647
+ /* "netCDF4/_netCDF4.pyx":3661
* bytestr = _strencode(newname)
* newnamec = bytestr
* ierr = nc_rename_att(self._grpid, self._varid, oldnamec, newnamec) # <<<<<<<<<<<<<<
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
__pyx_v_ierr = nc_rename_att(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_oldnamec, __pyx_v_newnamec);
- /* "netCDF4/_netCDF4.pyx":3648
+ /* "netCDF4/_netCDF4.pyx":3662
* newnamec = bytestr
* ierr = nc_rename_att(self._grpid, self._varid, oldnamec, newnamec)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
*/
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3649
+ /* "netCDF4/_netCDF4.pyx":3663
* ierr = nc_rename_att(self._grpid, self._varid, oldnamec, newnamec)
* if ierr != NC_NOERR:
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
*
* def __getitem__(self, elem):
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3649; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3663, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3649; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3663, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3649; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3663, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3649; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3663, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3648
+ /* "netCDF4/_netCDF4.pyx":3662
* newnamec = bytestr
* ierr = nc_rename_att(self._grpid, self._varid, oldnamec, newnamec)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
*/
}
- /* "netCDF4/_netCDF4.pyx":3635
+ /* "netCDF4/_netCDF4.pyx":3649
* return self.getncattr(name)
*
* def renameAttribute(self, oldname, newname): # <<<<<<<<<<<<<<
@@ -36188,8 +36188,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_42renameAttribute(struct
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3651
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+/* "netCDF4/_netCDF4.pyx":3665
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def __getitem__(self, elem): # <<<<<<<<<<<<<<
* # This special method is used to index the netCDF variable
@@ -36246,21 +36246,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
double __pyx_t_18;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getitem__", 0);
- /* "netCDF4/_netCDF4.pyx":3657
+ /* "netCDF4/_netCDF4.pyx":3671
* # arguments to the nc_get_var() function, and is much more easy
* # to use.
* start, count, stride, put_ind = _StartCountStride(elem,self.shape) # <<<<<<<<<<<<<<
* datashape = _out_array_shape(count)
* if self._isvlen:
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_StartCountStride); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_StartCountStride); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
__pyx_t_5 = 0;
@@ -36274,7 +36271,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_t_5 = 1;
}
}
- __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -36285,7 +36282,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -36299,7 +36296,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
if (unlikely(size != 4)) {
if (size > 4) __Pyx_RaiseTooManyValuesError(4);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3671, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -36322,7 +36319,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
Py_ssize_t i;
PyObject** temps[4] = {&__pyx_t_2,&__pyx_t_6,&__pyx_t_3,&__pyx_t_4};
for (i=0; i < 4; i++) {
- PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 3671, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
@@ -36332,7 +36329,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
} else {
Py_ssize_t index = -1;
PyObject** temps[4] = {&__pyx_t_2,&__pyx_t_6,&__pyx_t_3,&__pyx_t_4};
- __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
@@ -36341,7 +36338,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 4) < 0) __PYX_ERR(0, 3671, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L4_unpacking_done;
@@ -36349,7 +36346,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3671, __pyx_L1_error)
__pyx_L4_unpacking_done:;
}
__pyx_v_start = __pyx_t_2;
@@ -36361,14 +36358,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_v_put_ind = __pyx_t_4;
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3658
+ /* "netCDF4/_netCDF4.pyx":3672
* # to use.
* start, count, stride, put_ind = _StartCountStride(elem,self.shape)
* datashape = _out_array_shape(count) # <<<<<<<<<<<<<<
* if self._isvlen:
* data = numpy.empty(datashape, dtype='O')
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_out_array_shape); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_out_array_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
@@ -36381,16 +36378,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_count); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_count);
__Pyx_GIVEREF(__pyx_v_count);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_count);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -36398,37 +36395,37 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_v_datashape = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3659
+ /* "netCDF4/_netCDF4.pyx":3673
* start, count, stride, put_ind = _StartCountStride(elem,self.shape)
* datashape = _out_array_shape(count)
* if self._isvlen: # <<<<<<<<<<<<<<
* data = numpy.empty(datashape, dtype='O')
* else:
*/
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3673, __pyx_L1_error)
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3660
+ /* "netCDF4/_netCDF4.pyx":3674
* datashape = _out_array_shape(count)
* if self._isvlen:
* data = numpy.empty(datashape, dtype='O') # <<<<<<<<<<<<<<
* else:
* data = numpy.empty(datashape, dtype=self.dtype)
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3674, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3674, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3674, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_datashape);
__Pyx_GIVEREF(__pyx_v_datashape);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_datashape);
- __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3674, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_n_s_O) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_n_s_O) < 0) __PYX_ERR(0, 3674, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3674, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -36436,7 +36433,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_v_data = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3659
+ /* "netCDF4/_netCDF4.pyx":3673
* start, count, stride, put_ind = _StartCountStride(elem,self.shape)
* datashape = _out_array_shape(count)
* if self._isvlen: # <<<<<<<<<<<<<<
@@ -36446,7 +36443,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
goto __pyx_L5;
}
- /* "netCDF4/_netCDF4.pyx":3662
+ /* "netCDF4/_netCDF4.pyx":3676
* data = numpy.empty(datashape, dtype='O')
* else:
* data = numpy.empty(datashape, dtype=self.dtype) # <<<<<<<<<<<<<<
@@ -36454,20 +36451,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
* # Determine which dimensions need to be
*/
/*else*/ {
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3662; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3676, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3662; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3676, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3662; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3676, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_datashape);
__Pyx_GIVEREF(__pyx_v_datashape);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_datashape);
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3662; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3676, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_v_self->dtype) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3662; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3662; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_v_self->dtype) < 0) __PYX_ERR(0, 3676, __pyx_L1_error)
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3676, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -36477,28 +36474,28 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
__pyx_L5:;
- /* "netCDF4/_netCDF4.pyx":3668
+ /* "netCDF4/_netCDF4.pyx":3682
* # The convention used is that for those cases,
* # put_ind for this dimension is set to -1 by _StartCountStride.
* squeeze = data.ndim * [slice(None),] # <<<<<<<<<<<<<<
* for i,n in enumerate(put_ind.shape[:-1]):
* if n == 1 and put_ind[...,i].ravel()[0] == -1:
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3682, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3682, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __Pyx_INCREF(__pyx_slice__53);
- __Pyx_GIVEREF(__pyx_slice__53);
- PyList_SET_ITEM(__pyx_t_1, 0, __pyx_slice__53);
- __pyx_t_3 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_INCREF(__pyx_slice__54);
+ __Pyx_GIVEREF(__pyx_slice__54);
+ PyList_SET_ITEM(__pyx_t_1, 0, __pyx_slice__54);
+ __pyx_t_3 = PyNumber_Multiply(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3682, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_squeeze = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3669
+ /* "netCDF4/_netCDF4.pyx":3683
* # put_ind for this dimension is set to -1 by _StartCountStride.
* squeeze = data.ndim * [slice(None),]
* for i,n in enumerate(put_ind.shape[:-1]): # <<<<<<<<<<<<<<
@@ -36507,18 +36504,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
__Pyx_INCREF(__pyx_int_0);
__pyx_t_3 = __pyx_int_0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_t_1, 0, -1L, NULL, NULL, &__pyx_slice__54, 0, 1, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_t_1, 0, -1L, NULL, NULL, &__pyx_slice__55, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
__pyx_t_1 = __pyx_t_4; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3683, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
for (;;) {
@@ -36526,17 +36523,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 3683, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 3683, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -36546,7 +36543,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3683, __pyx_L1_error)
}
break;
}
@@ -36556,29 +36553,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_t_4 = 0;
__Pyx_INCREF(__pyx_t_3);
__Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_3);
- __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3);
__pyx_t_3 = __pyx_t_4;
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3670
+ /* "netCDF4/_netCDF4.pyx":3684
* squeeze = data.ndim * [slice(None),]
* for i,n in enumerate(put_ind.shape[:-1]):
* if n == 1 and put_ind[...,i].ravel()[0] == -1: # <<<<<<<<<<<<<<
* squeeze[i] = 0
*
*/
- __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_v_n, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_v_n, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_11) {
} else {
__pyx_t_9 = __pyx_t_11;
goto __pyx_L9_bool_binop_done;
}
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(Py_Ellipsis);
__Pyx_GIVEREF(Py_Ellipsis);
@@ -36586,10 +36583,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_INCREF(__pyx_v_i);
__Pyx_GIVEREF(__pyx_v_i);
PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_v_i);
- __pyx_t_2 = PyObject_GetItem(__pyx_v_put_ind, __pyx_t_6); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_v_put_ind, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ravel); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ravel); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -36603,35 +36600,35 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (__pyx_t_2) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3684, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_6, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_6, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3670; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3684, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_9 = __pyx_t_11;
__pyx_L9_bool_binop_done:;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3671
+ /* "netCDF4/_netCDF4.pyx":3685
* for i,n in enumerate(put_ind.shape[:-1]):
* if n == 1 and put_ind[...,i].ravel()[0] == -1:
* squeeze[i] = 0 # <<<<<<<<<<<<<<
*
* # Reshape the arrays so we can iterate over them.
*/
- if (unlikely(PyObject_SetItem(__pyx_v_squeeze, __pyx_v_i, __pyx_int_0) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3671; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_squeeze, __pyx_v_i, __pyx_int_0) < 0)) __PYX_ERR(0, 3685, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3670
+ /* "netCDF4/_netCDF4.pyx":3684
* squeeze = data.ndim * [slice(None),]
* for i,n in enumerate(put_ind.shape[:-1]):
* if n == 1 and put_ind[...,i].ravel()[0] == -1: # <<<<<<<<<<<<<<
@@ -36640,7 +36637,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":3669
+ /* "netCDF4/_netCDF4.pyx":3683
* # put_ind for this dimension is set to -1 by _StartCountStride.
* squeeze = data.ndim * [slice(None),]
* for i,n in enumerate(put_ind.shape[:-1]): # <<<<<<<<<<<<<<
@@ -36651,28 +36648,28 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3674
+ /* "netCDF4/_netCDF4.pyx":3688
*
* # Reshape the arrays so we can iterate over them.
* start = start.reshape((-1, self.ndim or 1)) # <<<<<<<<<<<<<<
* count = count.reshape((-1, self.ndim or 1))
* stride = stride.reshape((-1, self.ndim or 1))
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_start, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_start, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3688, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3688, __pyx_L1_error)
if (!__pyx_t_9) {
} else {
__Pyx_INCREF(__pyx_v_self->ndim);
__pyx_t_4 = __pyx_v_self->ndim;
goto __pyx_L11_bool_binop_done;
}
- __pyx_t_6 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3688, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = __pyx_t_6;
__pyx_t_6 = 0;
__pyx_L11_bool_binop_done:;
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3688, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -36691,17 +36688,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_4) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3688, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3688, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3688, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -36709,28 +36706,28 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_DECREF_SET(__pyx_v_start, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3675
+ /* "netCDF4/_netCDF4.pyx":3689
* # Reshape the arrays so we can iterate over them.
* start = start.reshape((-1, self.ndim or 1))
* count = count.reshape((-1, self.ndim or 1)) # <<<<<<<<<<<<<<
* stride = stride.reshape((-1, self.ndim or 1))
* put_ind = put_ind.reshape((-1, self.ndim or 1))
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_count, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_count, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3689, __pyx_L1_error)
if (!__pyx_t_9) {
} else {
__Pyx_INCREF(__pyx_v_self->ndim);
__pyx_t_2 = __pyx_v_self->ndim;
goto __pyx_L13_bool_binop_done;
}
- __pyx_t_6 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_2 = __pyx_t_6;
__pyx_t_6 = 0;
__pyx_L13_bool_binop_done:;
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -36749,17 +36746,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_2) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3689, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -36767,28 +36764,28 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_DECREF_SET(__pyx_v_count, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3676
+ /* "netCDF4/_netCDF4.pyx":3690
* start = start.reshape((-1, self.ndim or 1))
* count = count.reshape((-1, self.ndim or 1))
* stride = stride.reshape((-1, self.ndim or 1)) # <<<<<<<<<<<<<<
* put_ind = put_ind.reshape((-1, self.ndim or 1))
*
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_stride, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_stride, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3690, __pyx_L1_error)
if (!__pyx_t_9) {
} else {
__Pyx_INCREF(__pyx_v_self->ndim);
__pyx_t_4 = __pyx_v_self->ndim;
goto __pyx_L15_bool_binop_done;
}
- __pyx_t_6 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = __pyx_t_6;
__pyx_t_6 = 0;
__pyx_L15_bool_binop_done:;
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -36807,17 +36804,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_4) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3690, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3676; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -36825,28 +36822,28 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_DECREF_SET(__pyx_v_stride, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3677
+ /* "netCDF4/_netCDF4.pyx":3691
* count = count.reshape((-1, self.ndim or 1))
* stride = stride.reshape((-1, self.ndim or 1))
* put_ind = put_ind.reshape((-1, self.ndim or 1)) # <<<<<<<<<<<<<<
*
* # Fill output array with data chunks.
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3677; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_reshape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3691, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3677; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3691, __pyx_L1_error)
if (!__pyx_t_9) {
} else {
__Pyx_INCREF(__pyx_v_self->ndim);
__pyx_t_2 = __pyx_v_self->ndim;
goto __pyx_L17_bool_binop_done;
}
- __pyx_t_6 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3677; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3691, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_2 = __pyx_t_6;
__pyx_t_6 = 0;
__pyx_L17_bool_binop_done:;
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3677; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3691, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -36865,17 +36862,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_2) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3677; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3691, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3677; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3691, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3677; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3691, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -36883,14 +36880,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_DECREF_SET(__pyx_v_put_ind, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3680
+ /* "netCDF4/_netCDF4.pyx":3694
*
* # Fill output array with data chunks.
* for (a,b,c,i) in zip(start, count, stride, put_ind): # <<<<<<<<<<<<<<
* datout = self._get(a,b,c)
* if not hasattr(datout,'shape') or data.shape == datout.shape:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_4 = NULL;
__pyx_t_5 = 0;
@@ -36904,7 +36901,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_t_5 = 1;
}
}
- __pyx_t_6 = PyTuple_New(4+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(4+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -36921,7 +36918,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_INCREF(__pyx_v_put_ind);
__Pyx_GIVEREF(__pyx_v_put_ind);
PyTuple_SET_ITEM(__pyx_t_6, 3+__pyx_t_5, __pyx_v_put_ind);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -36929,9 +36926,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3694, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
for (;;) {
@@ -36939,17 +36936,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 3694, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 3694, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
}
@@ -36959,7 +36956,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3694, __pyx_L1_error)
}
break;
}
@@ -36975,7 +36972,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
if (unlikely(size != 4)) {
if (size > 4) __Pyx_RaiseTooManyValuesError(4);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3694, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -36998,7 +36995,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
Py_ssize_t i;
PyObject** temps[4] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_2,&__pyx_t_7};
for (i=0; i < 4; i++) {
- PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 3694, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
@@ -37008,7 +37005,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
} else {
Py_ssize_t index = -1;
PyObject** temps[4] = {&__pyx_t_6,&__pyx_t_4,&__pyx_t_2,&__pyx_t_7};
- __pyx_t_12 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_12)->tp_iternext;
@@ -37017,7 +37014,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_12), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_12), 4) < 0) __PYX_ERR(0, 3694, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
goto __pyx_L22_unpacking_done;
@@ -37025,7 +37022,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3694, __pyx_L1_error)
__pyx_L22_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_6);
@@ -37037,14 +37034,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3681
+ /* "netCDF4/_netCDF4.pyx":3695
* # Fill output array with data chunks.
* for (a,b,c,i) in zip(start, count, stride, put_ind):
* datout = self._get(a,b,c) # <<<<<<<<<<<<<<
* if not hasattr(datout,'shape') or data.shape == datout.shape:
* data = datout
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3681; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_2 = NULL;
__pyx_t_13 = 0;
@@ -37058,7 +37055,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_t_13 = 1;
}
}
- __pyx_t_4 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3681; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (__pyx_t_2) {
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -37072,41 +37069,41 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_INCREF(__pyx_v_c);
__Pyx_GIVEREF(__pyx_v_c);
PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_13, __pyx_v_c);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3681; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF_SET(__pyx_v_datout, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3682
+ /* "netCDF4/_netCDF4.pyx":3696
* for (a,b,c,i) in zip(start, count, stride, put_ind):
* datout = self._get(a,b,c)
* if not hasattr(datout,'shape') or data.shape == datout.shape: # <<<<<<<<<<<<<<
* data = datout
* else:
*/
- __pyx_t_11 = PyObject_HasAttr(__pyx_v_datout, __pyx_n_s_shape); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyObject_HasAttr(__pyx_v_datout, __pyx_n_s_shape); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3696, __pyx_L1_error)
__pyx_t_14 = ((!(__pyx_t_11 != 0)) != 0);
if (!__pyx_t_14) {
} else {
__pyx_t_9 = __pyx_t_14;
goto __pyx_L24_bool_binop_done;
}
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3696, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_datout, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_datout, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3696, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3696, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_14 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 3696, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_9 = __pyx_t_14;
__pyx_L24_bool_binop_done:;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3683
+ /* "netCDF4/_netCDF4.pyx":3697
* datout = self._get(a,b,c)
* if not hasattr(datout,'shape') or data.shape == datout.shape:
* data = datout # <<<<<<<<<<<<<<
@@ -37116,7 +37113,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_INCREF(__pyx_v_datout);
__Pyx_DECREF_SET(__pyx_v_data, __pyx_v_datout);
- /* "netCDF4/_netCDF4.pyx":3682
+ /* "netCDF4/_netCDF4.pyx":3696
* for (a,b,c,i) in zip(start, count, stride, put_ind):
* datout = self._get(a,b,c)
* if not hasattr(datout,'shape') or data.shape == datout.shape: # <<<<<<<<<<<<<<
@@ -37126,7 +37123,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
goto __pyx_L23;
}
- /* "netCDF4/_netCDF4.pyx":3685
+ /* "netCDF4/_netCDF4.pyx":3699
* data = datout
* else:
* shape = getattr(data[tuple(i)], 'shape', ()) # <<<<<<<<<<<<<<
@@ -37134,49 +37131,49 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
* # special case of scalar VLEN
*/
/*else*/ {
- __pyx_t_4 = PySequence_Tuple(__pyx_v_i); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_Tuple(__pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3699, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = PyObject_GetItem(__pyx_v_data, __pyx_t_4); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3685; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = PyObject_GetItem(__pyx_v_data, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3699, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetAttr3(__pyx_t_7, __pyx_n_s_shape, __pyx_empty_tuple); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetAttr3(__pyx_t_7, __pyx_n_s_shape, __pyx_empty_tuple); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3699, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF_SET(__pyx_v_shape, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3686
+ /* "netCDF4/_netCDF4.pyx":3700
* else:
* shape = getattr(data[tuple(i)], 'shape', ())
* if self._isvlen and not len(self.dimensions): # <<<<<<<<<<<<<<
* # special case of scalar VLEN
* data[0] = datout
*/
- __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_14 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3686; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 3700, __pyx_L1_error)
if (__pyx_t_14) {
} else {
__pyx_t_9 = __pyx_t_14;
goto __pyx_L27_bool_binop_done;
}
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3686; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3700, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_13 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3686; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 3700, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_14 = ((!(__pyx_t_13 != 0)) != 0);
__pyx_t_9 = __pyx_t_14;
__pyx_L27_bool_binop_done:;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3688
+ /* "netCDF4/_netCDF4.pyx":3702
* if self._isvlen and not len(self.dimensions):
* # special case of scalar VLEN
* data[0] = datout # <<<<<<<<<<<<<<
* else:
* data[tuple(i)] = datout.reshape(shape)
*/
- if (unlikely(__Pyx_SetItemInt(__pyx_v_data, 0, __pyx_v_datout, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3688; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_SetItemInt(__pyx_v_data, 0, __pyx_v_datout, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) __PYX_ERR(0, 3702, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3686
+ /* "netCDF4/_netCDF4.pyx":3700
* else:
* shape = getattr(data[tuple(i)], 'shape', ())
* if self._isvlen and not len(self.dimensions): # <<<<<<<<<<<<<<
@@ -37186,7 +37183,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
goto __pyx_L26;
}
- /* "netCDF4/_netCDF4.pyx":3690
+ /* "netCDF4/_netCDF4.pyx":3704
* data[0] = datout
* else:
* data[tuple(i)] = datout.reshape(shape) # <<<<<<<<<<<<<<
@@ -37194,7 +37191,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
* # Remove extra singleton dimensions.
*/
/*else*/ {
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_datout, __pyx_n_s_reshape); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_datout, __pyx_n_s_reshape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -37207,23 +37204,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_3) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_shape); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_shape);
__Pyx_GIVEREF(__pyx_v_shape);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_shape);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_2, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = PySequence_Tuple(__pyx_v_i); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_Tuple(__pyx_v_i); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- if (unlikely(PyObject_SetItem(__pyx_v_data, __pyx_t_7, __pyx_t_4) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_data, __pyx_t_7, __pyx_t_4) < 0)) __PYX_ERR(0, 3704, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -37231,7 +37228,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
__pyx_L23:;
- /* "netCDF4/_netCDF4.pyx":3680
+ /* "netCDF4/_netCDF4.pyx":3694
*
* # Fill output array with data chunks.
* for (a,b,c,i) in zip(start, count, stride, put_ind): # <<<<<<<<<<<<<<
@@ -37241,33 +37238,33 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3693
+ /* "netCDF4/_netCDF4.pyx":3707
*
* # Remove extra singleton dimensions.
* if hasattr(data,'shape'): # <<<<<<<<<<<<<<
* data = data[tuple(squeeze)]
* if hasattr(data,'ndim') and self.ndim == 0:
*/
- __pyx_t_9 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3693; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 3707, __pyx_L1_error)
__pyx_t_14 = (__pyx_t_9 != 0);
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":3694
+ /* "netCDF4/_netCDF4.pyx":3708
* # Remove extra singleton dimensions.
* if hasattr(data,'shape'):
* data = data[tuple(squeeze)] # <<<<<<<<<<<<<<
* if hasattr(data,'ndim') and self.ndim == 0:
* # Make sure a numpy scalar array is returned instead of a 1-d array of
*/
- __pyx_t_1 = PySequence_Tuple(__pyx_v_squeeze); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_Tuple(__pyx_v_squeeze); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3708, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyObject_GetItem(__pyx_v_data, __pyx_t_1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3694; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_data, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3708, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3693
+ /* "netCDF4/_netCDF4.pyx":3707
*
* # Remove extra singleton dimensions.
* if hasattr(data,'shape'): # <<<<<<<<<<<<<<
@@ -37276,48 +37273,48 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":3695
+ /* "netCDF4/_netCDF4.pyx":3709
* if hasattr(data,'shape'):
* data = data[tuple(squeeze)]
* if hasattr(data,'ndim') and self.ndim == 0: # <<<<<<<<<<<<<<
* # Make sure a numpy scalar array is returned instead of a 1-d array of
* # length 1.
*/
- __pyx_t_9 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3695; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 3709, __pyx_L1_error)
__pyx_t_11 = (__pyx_t_9 != 0);
if (__pyx_t_11) {
} else {
__pyx_t_14 = __pyx_t_11;
goto __pyx_L31_bool_binop_done;
}
- __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_v_self->ndim, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3695; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_v_self->ndim, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3709, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3695; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3709, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_14 = __pyx_t_11;
__pyx_L31_bool_binop_done:;
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":3698
+ /* "netCDF4/_netCDF4.pyx":3712
* # Make sure a numpy scalar array is returned instead of a 1-d array of
* # length 1.
* if data.ndim != 0: data = numpy.asarray(data[0]) # <<<<<<<<<<<<<<
*
* # if auto_scale mode set to True, (through
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_14 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_14) {
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_asarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_data, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_data, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_2 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) {
@@ -37330,17 +37327,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3698; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3712, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
@@ -37349,7 +37346,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3695
+ /* "netCDF4/_netCDF4.pyx":3709
* if hasattr(data,'shape'):
* data = data[tuple(squeeze)]
* if hasattr(data,'ndim') and self.ndim == 0: # <<<<<<<<<<<<<<
@@ -37358,7 +37355,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":3708
+ /* "netCDF4/_netCDF4.pyx":3722
* # missing_value/_Fill_Value.
* # ignore for compound, vlen or enum datatypes.
* try: # check to see if scale_factor and add_offset is valid (issue 176). # <<<<<<<<<<<<<<
@@ -37366,45 +37363,47 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
* if hasattr(self,'add_offset'): float(self.add_offset)
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3709
+ /* "netCDF4/_netCDF4.pyx":3723
* # ignore for compound, vlen or enum datatypes.
* try: # check to see if scale_factor and add_offset is valid (issue 176).
* if hasattr(self,'scale_factor'): float(self.scale_factor) # <<<<<<<<<<<<<<
* if hasattr(self,'add_offset'): float(self.add_offset)
* valid_scaleoffset = True
*/
- __pyx_t_14 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3709; __pyx_clineno = __LINE__; goto __pyx_L34_error;}
+ __pyx_t_14 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(0, 3723, __pyx_L34_error)
__pyx_t_11 = (__pyx_t_14 != 0);
if (__pyx_t_11) {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3709; __pyx_clineno = __LINE__; goto __pyx_L34_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3723, __pyx_L34_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_18 = __Pyx_PyObject_AsDouble(__pyx_t_1); if (unlikely(__pyx_t_18 == ((double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3709; __pyx_clineno = __LINE__; goto __pyx_L34_error;}
+ __pyx_t_18 = __Pyx_PyObject_AsDouble(__pyx_t_1); if (unlikely(__pyx_t_18 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3723, __pyx_L34_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3710
+ /* "netCDF4/_netCDF4.pyx":3724
* try: # check to see if scale_factor and add_offset is valid (issue 176).
* if hasattr(self,'scale_factor'): float(self.scale_factor)
* if hasattr(self,'add_offset'): float(self.add_offset) # <<<<<<<<<<<<<<
* valid_scaleoffset = True
* except:
*/
- __pyx_t_11 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3710; __pyx_clineno = __LINE__; goto __pyx_L34_error;}
+ __pyx_t_11 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3724, __pyx_L34_error)
__pyx_t_14 = (__pyx_t_11 != 0);
if (__pyx_t_14) {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3710; __pyx_clineno = __LINE__; goto __pyx_L34_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3724, __pyx_L34_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_18 = __Pyx_PyObject_AsDouble(__pyx_t_1); if (unlikely(__pyx_t_18 == ((double)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3710; __pyx_clineno = __LINE__; goto __pyx_L34_error;}
+ __pyx_t_18 = __Pyx_PyObject_AsDouble(__pyx_t_1); if (unlikely(__pyx_t_18 == ((double)-1) && PyErr_Occurred())) __PYX_ERR(0, 3724, __pyx_L34_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3711
+ /* "netCDF4/_netCDF4.pyx":3725
* if hasattr(self,'scale_factor'): float(self.scale_factor)
* if hasattr(self,'add_offset'): float(self.add_offset)
* valid_scaleoffset = True # <<<<<<<<<<<<<<
@@ -37413,7 +37412,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
__pyx_v_valid_scaleoffset = 1;
- /* "netCDF4/_netCDF4.pyx":3708
+ /* "netCDF4/_netCDF4.pyx":3722
* # missing_value/_Fill_Value.
* # ignore for compound, vlen or enum datatypes.
* try: # check to see if scale_factor and add_offset is valid (issue 176). # <<<<<<<<<<<<<<
@@ -37426,6 +37425,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
goto __pyx_L41_try_end;
__pyx_L34_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -37434,7 +37434,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3712
+ /* "netCDF4/_netCDF4.pyx":3726
* if hasattr(self,'add_offset'): float(self.add_offset)
* valid_scaleoffset = True
* except: # <<<<<<<<<<<<<<
@@ -37443,12 +37443,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
/*except:*/ {
__Pyx_AddTraceback("netCDF4._netCDF4.Variable.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3712; __pyx_clineno = __LINE__; goto __pyx_L36_except_error;}
+ if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_3) < 0) __PYX_ERR(0, 3726, __pyx_L36_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_3);
- /* "netCDF4/_netCDF4.pyx":3713
+ /* "netCDF4/_netCDF4.pyx":3727
* valid_scaleoffset = True
* except:
* valid_scaleoffset = False # <<<<<<<<<<<<<<
@@ -37457,17 +37457,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
__pyx_v_valid_scaleoffset = 0;
- /* "netCDF4/_netCDF4.pyx":3714
+ /* "netCDF4/_netCDF4.pyx":3728
* except:
* valid_scaleoffset = False
* if self.scale: # <<<<<<<<<<<<<<
* msg = 'invalid scale_factor or add_offset attribute, no unpacking done...'
* warnings.warn(msg)
*/
- __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_self->scale); if (unlikely(__pyx_t_14 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3714; __pyx_clineno = __LINE__; goto __pyx_L36_except_error;}
+ __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_v_self->scale); if (unlikely(__pyx_t_14 < 0)) __PYX_ERR(0, 3728, __pyx_L36_except_error)
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":3715
+ /* "netCDF4/_netCDF4.pyx":3729
* valid_scaleoffset = False
* if self.scale:
* msg = 'invalid scale_factor or add_offset attribute, no unpacking done...' # <<<<<<<<<<<<<<
@@ -37477,16 +37477,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_INCREF(__pyx_kp_s_invalid_scale_factor_or_add_offs);
__pyx_v_msg = __pyx_kp_s_invalid_scale_factor_or_add_offs;
- /* "netCDF4/_netCDF4.pyx":3716
+ /* "netCDF4/_netCDF4.pyx":3730
* if self.scale:
* msg = 'invalid scale_factor or add_offset attribute, no unpacking done...'
* warnings.warn(msg) # <<<<<<<<<<<<<<
* if self.mask and (self._isprimitive or self._isenum):
* data = self._toma(data)
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3716; __pyx_clineno = __LINE__; goto __pyx_L36_except_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3730, __pyx_L36_except_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warn); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3716; __pyx_clineno = __LINE__; goto __pyx_L36_except_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_warn); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3730, __pyx_L36_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -37500,23 +37500,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_2) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_msg); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3716; __pyx_clineno = __LINE__; goto __pyx_L36_except_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_msg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3730, __pyx_L36_except_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
- __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3716; __pyx_clineno = __LINE__; goto __pyx_L36_except_error;}
+ __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3730, __pyx_L36_except_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_v_msg);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3716; __pyx_clineno = __LINE__; goto __pyx_L36_except_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3730, __pyx_L36_except_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3714
+ /* "netCDF4/_netCDF4.pyx":3728
* except:
* valid_scaleoffset = False
* if self.scale: # <<<<<<<<<<<<<<
@@ -37531,19 +37531,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
__pyx_L36_except_error:;
- /* "netCDF4/_netCDF4.pyx":3708
+ /* "netCDF4/_netCDF4.pyx":3722
* # missing_value/_Fill_Value.
* # ignore for compound, vlen or enum datatypes.
* try: # check to see if scale_factor and add_offset is valid (issue 176). # <<<<<<<<<<<<<<
* if hasattr(self,'scale_factor'): float(self.scale_factor)
* if hasattr(self,'add_offset'): float(self.add_offset)
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17);
goto __pyx_L1_error;
__pyx_L35_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
@@ -37551,38 +37553,38 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_L41_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":3717
+ /* "netCDF4/_netCDF4.pyx":3731
* msg = 'invalid scale_factor or add_offset attribute, no unpacking done...'
* warnings.warn(msg)
* if self.mask and (self._isprimitive or self._isenum): # <<<<<<<<<<<<<<
* data = self._toma(data)
* if self.scale and self._isprimitive and valid_scaleoffset:
*/
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->mask); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3717; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->mask); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3731, __pyx_L1_error)
if (__pyx_t_11) {
} else {
__pyx_t_14 = __pyx_t_11;
goto __pyx_L48_bool_binop_done;
}
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3717; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3731, __pyx_L1_error)
if (!__pyx_t_11) {
} else {
__pyx_t_14 = __pyx_t_11;
goto __pyx_L48_bool_binop_done;
}
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3717; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3731, __pyx_L1_error)
__pyx_t_14 = __pyx_t_11;
__pyx_L48_bool_binop_done:;
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":3718
+ /* "netCDF4/_netCDF4.pyx":3732
* warnings.warn(msg)
* if self.mask and (self._isprimitive or self._isenum):
* data = self._toma(data) # <<<<<<<<<<<<<<
* if self.scale and self._isprimitive and valid_scaleoffset:
* # if variable has scale_factor and add_offset attributes, rescale.
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_toma); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_toma); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_1 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -37595,16 +37597,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
}
if (!__pyx_t_1) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_data);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -37612,7 +37614,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3717
+ /* "netCDF4/_netCDF4.pyx":3731
* msg = 'invalid scale_factor or add_offset attribute, no unpacking done...'
* warnings.warn(msg)
* if self.mask and (self._isprimitive or self._isenum): # <<<<<<<<<<<<<<
@@ -37621,20 +37623,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":3719
+ /* "netCDF4/_netCDF4.pyx":3733
* if self.mask and (self._isprimitive or self._isenum):
* data = self._toma(data)
* if self.scale and self._isprimitive and valid_scaleoffset: # <<<<<<<<<<<<<<
* # if variable has scale_factor and add_offset attributes, rescale.
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset') and\
*/
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->scale); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->scale); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3733, __pyx_L1_error)
if (__pyx_t_11) {
} else {
__pyx_t_14 = __pyx_t_11;
goto __pyx_L52_bool_binop_done;
}
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3733, __pyx_L1_error)
if (__pyx_t_11) {
} else {
__pyx_t_14 = __pyx_t_11;
@@ -37645,21 +37647,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_L52_bool_binop_done:;
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":3721
+ /* "netCDF4/_netCDF4.pyx":3735
* if self.scale and self._isprimitive and valid_scaleoffset:
* # if variable has scale_factor and add_offset attributes, rescale.
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset') and\ # <<<<<<<<<<<<<<
* (self.add_offset != 0.0 or self.scale_factor != 1.0):
* data = data*self.scale_factor + self.add_offset
*/
- __pyx_t_11 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3721; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3735, __pyx_L1_error)
__pyx_t_9 = (__pyx_t_11 != 0);
if (__pyx_t_9) {
} else {
__pyx_t_14 = __pyx_t_9;
goto __pyx_L56_bool_binop_done;
}
- __pyx_t_9 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3721; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 3735, __pyx_L1_error)
__pyx_t_11 = (__pyx_t_9 != 0);
if (__pyx_t_11) {
} else {
@@ -37667,34 +37669,34 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
goto __pyx_L56_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":3722
+ /* "netCDF4/_netCDF4.pyx":3736
* # if variable has scale_factor and add_offset attributes, rescale.
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset') and\
* (self.add_offset != 0.0 or self.scale_factor != 1.0): # <<<<<<<<<<<<<<
* data = data*self.scale_factor + self.add_offset
* # else if variable has only scale_factor attributes, rescale.
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3722; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3736, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_float_0_0, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3722; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_RichCompare(__pyx_t_3, __pyx_float_0_0, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3736, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3722; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3736, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (!__pyx_t_11) {
} else {
__pyx_t_14 = __pyx_t_11;
goto __pyx_L56_bool_binop_done;
}
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3722; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3736, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_3 = PyObject_RichCompare(__pyx_t_7, __pyx_float_1_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3722; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_7, __pyx_float_1_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3736, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3722; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3736, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_14 = __pyx_t_11;
__pyx_L56_bool_binop_done:;
- /* "netCDF4/_netCDF4.pyx":3721
+ /* "netCDF4/_netCDF4.pyx":3735
* if self.scale and self._isprimitive and valid_scaleoffset:
* # if variable has scale_factor and add_offset attributes, rescale.
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset') and\ # <<<<<<<<<<<<<<
@@ -37703,28 +37705,28 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":3723
+ /* "netCDF4/_netCDF4.pyx":3737
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset') and\
* (self.add_offset != 0.0 or self.scale_factor != 1.0):
* data = data*self.scale_factor + self.add_offset # <<<<<<<<<<<<<<
* # else if variable has only scale_factor attributes, rescale.
* elif hasattr(self, 'scale_factor') and self.scale_factor != 1.0:
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3723; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3737, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = PyNumber_Multiply(__pyx_v_data, __pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3723; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyNumber_Multiply(__pyx_v_data, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3737, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3723; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3737, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyNumber_Add(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3723; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Add(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3737, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3721
+ /* "netCDF4/_netCDF4.pyx":3735
* if self.scale and self._isprimitive and valid_scaleoffset:
* # if variable has scale_factor and add_offset attributes, rescale.
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset') and\ # <<<<<<<<<<<<<<
@@ -37734,46 +37736,46 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
goto __pyx_L55;
}
- /* "netCDF4/_netCDF4.pyx":3725
+ /* "netCDF4/_netCDF4.pyx":3739
* data = data*self.scale_factor + self.add_offset
* # else if variable has only scale_factor attributes, rescale.
* elif hasattr(self, 'scale_factor') and self.scale_factor != 1.0: # <<<<<<<<<<<<<<
* data = data*self.scale_factor
* # else if variable has only add_offset attributes, rescale.
*/
- __pyx_t_11 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3725; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 3739, __pyx_L1_error)
__pyx_t_9 = (__pyx_t_11 != 0);
if (__pyx_t_9) {
} else {
__pyx_t_14 = __pyx_t_9;
goto __pyx_L60_bool_binop_done;
}
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3725; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3739, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_float_1_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3725; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_float_1_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3739, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3725; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3739, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_14 = __pyx_t_9;
__pyx_L60_bool_binop_done:;
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":3726
+ /* "netCDF4/_netCDF4.pyx":3740
* # else if variable has only scale_factor attributes, rescale.
* elif hasattr(self, 'scale_factor') and self.scale_factor != 1.0:
* data = data*self.scale_factor # <<<<<<<<<<<<<<
* # else if variable has only add_offset attributes, rescale.
* elif hasattr(self, 'add_offset') and self.add_offset != 0.0:
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3726; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3740, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyNumber_Multiply(__pyx_v_data, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3726; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Multiply(__pyx_v_data, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3740, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3725
+ /* "netCDF4/_netCDF4.pyx":3739
* data = data*self.scale_factor + self.add_offset
* # else if variable has only scale_factor attributes, rescale.
* elif hasattr(self, 'scale_factor') and self.scale_factor != 1.0: # <<<<<<<<<<<<<<
@@ -37783,46 +37785,46 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
goto __pyx_L55;
}
- /* "netCDF4/_netCDF4.pyx":3728
+ /* "netCDF4/_netCDF4.pyx":3742
* data = data*self.scale_factor
* # else if variable has only add_offset attributes, rescale.
* elif hasattr(self, 'add_offset') and self.add_offset != 0.0: # <<<<<<<<<<<<<<
* data = data + self.add_offset
* return data
*/
- __pyx_t_9 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3728; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 3742, __pyx_L1_error)
__pyx_t_11 = (__pyx_t_9 != 0);
if (__pyx_t_11) {
} else {
__pyx_t_14 = __pyx_t_11;
goto __pyx_L62_bool_binop_done;
}
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3728; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3742, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_float_0_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3728; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_float_0_0, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3742, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3728; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 3742, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_14 = __pyx_t_11;
__pyx_L62_bool_binop_done:;
if (__pyx_t_14) {
- /* "netCDF4/_netCDF4.pyx":3729
+ /* "netCDF4/_netCDF4.pyx":3743
* # else if variable has only add_offset attributes, rescale.
* elif hasattr(self, 'add_offset') and self.add_offset != 0.0:
* data = data + self.add_offset # <<<<<<<<<<<<<<
* return data
*
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3743, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyNumber_Add(__pyx_v_data, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Add(__pyx_v_data, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3743, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3728
+ /* "netCDF4/_netCDF4.pyx":3742
* data = data*self.scale_factor
* # else if variable has only add_offset attributes, rescale.
* elif hasattr(self, 'add_offset') and self.add_offset != 0.0: # <<<<<<<<<<<<<<
@@ -37832,7 +37834,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
}
__pyx_L55:;
- /* "netCDF4/_netCDF4.pyx":3719
+ /* "netCDF4/_netCDF4.pyx":3733
* if self.mask and (self._isprimitive or self._isenum):
* data = self._toma(data)
* if self.scale and self._isprimitive and valid_scaleoffset: # <<<<<<<<<<<<<<
@@ -37841,7 +37843,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":3730
+ /* "netCDF4/_netCDF4.pyx":3744
* elif hasattr(self, 'add_offset') and self.add_offset != 0.0:
* data = data + self.add_offset
* return data # <<<<<<<<<<<<<<
@@ -37853,8 +37855,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
__pyx_r = __pyx_v_data;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3651
- * raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ /* "netCDF4/_netCDF4.pyx":3665
+ * raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
*
* def __getitem__(self, elem): # <<<<<<<<<<<<<<
* # This special method is used to index the netCDF variable
@@ -37893,7 +37895,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_44__getitem__(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3732
+/* "netCDF4/_netCDF4.pyx":3746
* return data
*
* def _toma(self,data): # <<<<<<<<<<<<<<
@@ -37946,29 +37948,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
PyObject *(*__pyx_t_14)(PyObject *);
char *__pyx_t_15;
int __pyx_t_16;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_toma", 0);
__Pyx_INCREF(__pyx_v_data);
- /* "netCDF4/_netCDF4.pyx":3736
+ /* "netCDF4/_netCDF4.pyx":3750
* # private function for creating a masked array, masking missing_values
* # and/or _FillValues.
* totalmask = numpy.zeros(data.shape, numpy.bool) # <<<<<<<<<<<<<<
* fill_value = None
* if hasattr(self, 'missing_value'):
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3736; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3736; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3736; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3736; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_bool); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3736; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_bool); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -37983,7 +37982,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_6 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3736; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -37994,47 +37993,47 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_5);
__pyx_t_2 = 0;
__pyx_t_5 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3736; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3750, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_totalmask = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3737
+ /* "netCDF4/_netCDF4.pyx":3751
* # and/or _FillValues.
* totalmask = numpy.zeros(data.shape, numpy.bool)
* fill_value = None # <<<<<<<<<<<<<<
* if hasattr(self, 'missing_value'):
- * mval = numpy.array(self.missing_value, self.dtype)
+ * # note: missing_value has to have same endian-ness as variable
*/
__Pyx_INCREF(Py_None);
__pyx_v_fill_value = Py_None;
- /* "netCDF4/_netCDF4.pyx":3738
+ /* "netCDF4/_netCDF4.pyx":3752
* totalmask = numpy.zeros(data.shape, numpy.bool)
* fill_value = None
* if hasattr(self, 'missing_value'): # <<<<<<<<<<<<<<
- * mval = numpy.array(self.missing_value, self.dtype)
- * if (self.endian() == 'big' and is_native_little) or\
+ * # note: missing_value has to have same endian-ness as variable
+ * # or this won't work.
*/
- __pyx_t_8 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 3752, __pyx_L1_error)
__pyx_t_9 = (__pyx_t_8 != 0);
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3739
- * fill_value = None
- * if hasattr(self, 'missing_value'):
+ /* "netCDF4/_netCDF4.pyx":3755
+ * # note: missing_value has to have same endian-ness as variable
+ * # or this won't work.
* mval = numpy.array(self.missing_value, self.dtype) # <<<<<<<<<<<<<<
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big):
+ * if mval.shape == (): # mval a scalar.
+ * hasmval = data==mval
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3755, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3755, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3755, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = NULL;
__pyx_t_6 = 0;
@@ -38048,7 +38047,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_6 = 1;
}
}
- __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3755, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5); __pyx_t_5 = NULL;
@@ -38059,157 +38058,40 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_GIVEREF(__pyx_v_self->dtype);
PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_6, __pyx_v_self->dtype);
__pyx_t_3 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3739; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3755, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_v_mval = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":3740
- * if hasattr(self, 'missing_value'):
+ /* "netCDF4/_netCDF4.pyx":3756
+ * # or this won't work.
* mval = numpy.array(self.missing_value, self.dtype)
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * mval.byteswap(True)
- */
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
- __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
- if (likely(__pyx_t_2)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
- __Pyx_INCREF(__pyx_t_2);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_7, function);
- }
- }
- if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- } else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- }
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_big, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (!__pyx_t_8) {
- goto __pyx_L6_next_or;
- } else {
- }
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3740; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (!__pyx_t_8) {
- } else {
- __pyx_t_9 = __pyx_t_8;
- goto __pyx_L5_bool_binop_done;
- }
- __pyx_L6_next_or:;
-
- /* "netCDF4/_netCDF4.pyx":3741
- * mval = numpy.array(self.missing_value, self.dtype)
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big): # <<<<<<<<<<<<<<
- * mval.byteswap(True)
- * if mval.shape == (): # mval a scalar.
- */
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
- __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
- if (likely(__pyx_t_2)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
- __Pyx_INCREF(__pyx_t_2);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_7, function);
- }
- }
- if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- } else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- }
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_little, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (__pyx_t_8) {
- } else {
- __pyx_t_9 = __pyx_t_8;
- goto __pyx_L5_bool_binop_done;
- }
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3741; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_9 = __pyx_t_8;
- __pyx_L5_bool_binop_done:;
-
- /* "netCDF4/_netCDF4.pyx":3740
- * if hasattr(self, 'missing_value'):
- * mval = numpy.array(self.missing_value, self.dtype)
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * mval.byteswap(True)
- */
- if (__pyx_t_9) {
-
- /* "netCDF4/_netCDF4.pyx":3742
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big):
- * mval.byteswap(True) # <<<<<<<<<<<<<<
- * if mval.shape == (): # mval a scalar.
- * hasmval = data==mval
- */
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_mval, __pyx_n_s_byteswap); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3742; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3742; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-
- /* "netCDF4/_netCDF4.pyx":3740
- * if hasattr(self, 'missing_value'):
- * mval = numpy.array(self.missing_value, self.dtype)
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * mval.byteswap(True)
- */
- }
-
- /* "netCDF4/_netCDF4.pyx":3743
- * (self.endian() == 'little' and is_native_big):
- * mval.byteswap(True)
* if mval.shape == (): # mval a scalar. # <<<<<<<<<<<<<<
* hasmval = data==mval
* # is scalar missing value a NaN?
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_mval, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3743; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3743; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3743; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_mval, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3756, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = PyObject_RichCompare(__pyx_t_1, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3756, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3756, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3744
- * mval.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":3757
+ * mval = numpy.array(self.missing_value, self.dtype)
* if mval.shape == (): # mval a scalar.
* hasmval = data==mval # <<<<<<<<<<<<<<
* # is scalar missing value a NaN?
* try:
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_data, __pyx_v_mval, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3744; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_v_hasmval = __pyx_t_1;
- __pyx_t_1 = 0;
+ __pyx_t_7 = PyObject_RichCompare(__pyx_v_data, __pyx_v_mval, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3757, __pyx_L1_error)
+ __pyx_v_hasmval = __pyx_t_7;
+ __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3746
+ /* "netCDF4/_netCDF4.pyx":3759
* hasmval = data==mval
* # is scalar missing value a NaN?
* try: # <<<<<<<<<<<<<<
@@ -38217,53 +38099,55 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
* except TypeError: # isnan fails on some dtypes (issue 206)
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3747
+ /* "netCDF4/_netCDF4.pyx":3760
* # is scalar missing value a NaN?
* try:
* mvalisnan = numpy.isnan(mval) # <<<<<<<<<<<<<<
* except TypeError: # isnan fails on some dtypes (issue 206)
* mvalisnan = False
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3747; __pyx_clineno = __LINE__; goto __pyx_L10_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_isnan); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3747; __pyx_clineno = __LINE__; goto __pyx_L10_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3760, __pyx_L5_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_isnan); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3760, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = NULL;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
- __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
- if (likely(__pyx_t_7)) {
+ __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_1)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
- __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
- if (!__pyx_t_7) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_mval); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3747; __pyx_clineno = __LINE__; goto __pyx_L10_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ if (!__pyx_t_1) {
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_mval); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3760, __pyx_L5_error)
+ __Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3747; __pyx_clineno = __LINE__; goto __pyx_L10_error;}
+ __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3760, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_3);
- __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_INCREF(__pyx_v_mval);
__Pyx_GIVEREF(__pyx_v_mval);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_mval);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3747; __pyx_clineno = __LINE__; goto __pyx_L10_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3760, __pyx_L5_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_v_mvalisnan = __pyx_t_1;
- __pyx_t_1 = 0;
+ __pyx_v_mvalisnan = __pyx_t_7;
+ __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3746
+ /* "netCDF4/_netCDF4.pyx":3759
* hasmval = data==mval
* # is scalar missing value a NaN?
* try: # <<<<<<<<<<<<<<
@@ -38274,31 +38158,32 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
- goto __pyx_L17_try_end;
- __pyx_L10_error:;
+ goto __pyx_L12_try_end;
+ __pyx_L5_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
- __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3748
+ /* "netCDF4/_netCDF4.pyx":3761
* try:
* mvalisnan = numpy.isnan(mval)
* except TypeError: # isnan fails on some dtypes (issue 206) # <<<<<<<<<<<<<<
* mvalisnan = False
* else: # mval a vector.
*/
- __pyx_t_13 = PyErr_ExceptionMatches(__pyx_builtin_TypeError);
+ __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError);
if (__pyx_t_13) {
__Pyx_AddTraceback("netCDF4._netCDF4.Variable._toma", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3748; __pyx_clineno = __LINE__; goto __pyx_L12_except_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(0, 3761, __pyx_L7_except_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_3);
- /* "netCDF4/_netCDF4.pyx":3749
+ /* "netCDF4/_netCDF4.pyx":3762
* mvalisnan = numpy.isnan(mval)
* except TypeError: # isnan fails on some dtypes (issue 206)
* mvalisnan = False # <<<<<<<<<<<<<<
@@ -38307,45 +38192,47 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
__Pyx_INCREF(Py_False);
__Pyx_XDECREF_SET(__pyx_v_mvalisnan, Py_False);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- goto __pyx_L11_exception_handled;
+ goto __pyx_L6_exception_handled;
}
- goto __pyx_L12_except_error;
- __pyx_L12_except_error:;
+ goto __pyx_L7_except_error;
+ __pyx_L7_except_error:;
- /* "netCDF4/_netCDF4.pyx":3746
+ /* "netCDF4/_netCDF4.pyx":3759
* hasmval = data==mval
* # is scalar missing value a NaN?
* try: # <<<<<<<<<<<<<<
* mvalisnan = numpy.isnan(mval)
* except TypeError: # isnan fails on some dtypes (issue 206)
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
goto __pyx_L1_error;
- __pyx_L11_exception_handled:;
+ __pyx_L6_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
- __pyx_L17_try_end:;
+ __pyx_L12_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":3743
- * (self.endian() == 'little' and is_native_big):
- * mval.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":3756
+ * # or this won't work.
+ * mval = numpy.array(self.missing_value, self.dtype)
* if mval.shape == (): # mval a scalar. # <<<<<<<<<<<<<<
* hasmval = data==mval
* # is scalar missing value a NaN?
*/
- goto __pyx_L9;
+ goto __pyx_L4;
}
- /* "netCDF4/_netCDF4.pyx":3751
+ /* "netCDF4/_netCDF4.pyx":3764
* mvalisnan = False
* else: # mval a vector.
* hasmval = numpy.zeros(data.shape, numpy.bool) # <<<<<<<<<<<<<<
@@ -38353,34 +38240,34 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
* m = numpy.array(m)
*/
/*else*/ {
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3764, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_bool); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3764, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_bool); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = NULL;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = NULL;
__pyx_t_6 = 0;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
- __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
- if (likely(__pyx_t_7)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
- __Pyx_INCREF(__pyx_t_7);
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_7);
+ if (likely(__pyx_t_1)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_1, function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
__pyx_t_6 = 1;
}
}
- __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- if (__pyx_t_7) {
- __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7); __pyx_t_7 = NULL;
+ if (__pyx_t_1) {
+ __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL;
}
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_t_2);
@@ -38388,14 +38275,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, __pyx_t_5);
__pyx_t_2 = 0;
__pyx_t_5 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_v_hasmval = __pyx_t_3;
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3752
+ /* "netCDF4/_netCDF4.pyx":3765
* else: # mval a vector.
* hasmval = numpy.zeros(data.shape, numpy.bool)
* for m in mval: # <<<<<<<<<<<<<<
@@ -38406,54 +38293,54 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_3 = __pyx_v_mval; __Pyx_INCREF(__pyx_t_3); __pyx_t_6 = 0;
__pyx_t_14 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_mval); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3752; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_mval); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3765, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_14 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3752; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 3765, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_14)) {
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3752; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_7); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3765, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3752; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3765, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_1); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3752; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_7); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3765, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3752; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3765, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
#endif
}
} else {
- __pyx_t_1 = __pyx_t_14(__pyx_t_3);
- if (unlikely(!__pyx_t_1)) {
+ __pyx_t_7 = __pyx_t_14(__pyx_t_3);
+ if (unlikely(!__pyx_t_7)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3752; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3765, __pyx_L1_error)
}
break;
}
- __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_GOTREF(__pyx_t_7);
}
- __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_1);
- __pyx_t_1 = 0;
+ __Pyx_XDECREF_SET(__pyx_v_m, __pyx_t_7);
+ __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3753
+ /* "netCDF4/_netCDF4.pyx":3766
* hasmval = numpy.zeros(data.shape, numpy.bool)
* for m in mval:
* m = numpy.array(m) # <<<<<<<<<<<<<<
* hasmval += data == m
* if mval.shape == () and mvalisnan:
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3753; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3753; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -38467,38 +38354,38 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
}
}
if (!__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_m); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3753; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_m); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3766, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3753; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_m);
__Pyx_GIVEREF(__pyx_v_m);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_m);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3753; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3766, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF_SET(__pyx_v_m, __pyx_t_1);
- __pyx_t_1 = 0;
+ __Pyx_DECREF_SET(__pyx_v_m, __pyx_t_7);
+ __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3754
+ /* "netCDF4/_netCDF4.pyx":3767
* for m in mval:
* m = numpy.array(m)
* hasmval += data == m # <<<<<<<<<<<<<<
* if mval.shape == () and mvalisnan:
* mask = numpy.isnan(data)
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_data, __pyx_v_m, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3754; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_v_hasmval, __pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3754; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_RichCompare(__pyx_v_data, __pyx_v_m, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3767, __pyx_L1_error)
+ __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_v_hasmval, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3767, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF_SET(__pyx_v_hasmval, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3752
+ /* "netCDF4/_netCDF4.pyx":3765
* else: # mval a vector.
* hasmval = numpy.zeros(data.shape, numpy.bool)
* for m in mval: # <<<<<<<<<<<<<<
@@ -38508,114 +38395,114 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
- __pyx_L9:;
+ __pyx_L4:;
- /* "netCDF4/_netCDF4.pyx":3755
+ /* "netCDF4/_netCDF4.pyx":3768
* m = numpy.array(m)
* hasmval += data == m
* if mval.shape == () and mvalisnan: # <<<<<<<<<<<<<<
* mask = numpy.isnan(data)
* elif hasmval.any():
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_mval, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_mval, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3768, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3768, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3768, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_8) {
} else {
__pyx_t_9 = __pyx_t_8;
- goto __pyx_L23_bool_binop_done;
+ goto __pyx_L18_bool_binop_done;
}
- if (unlikely(!__pyx_v_mvalisnan)) { __Pyx_RaiseUnboundLocalError("mvalisnan"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3755; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_mvalisnan); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3755; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(!__pyx_v_mvalisnan)) { __Pyx_RaiseUnboundLocalError("mvalisnan"); __PYX_ERR(0, 3768, __pyx_L1_error) }
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_mvalisnan); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3768, __pyx_L1_error)
__pyx_t_9 = __pyx_t_8;
- __pyx_L23_bool_binop_done:;
+ __pyx_L18_bool_binop_done:;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3756
+ /* "netCDF4/_netCDF4.pyx":3769
* hasmval += data == m
* if mval.shape == () and mvalisnan:
* mask = numpy.isnan(data) # <<<<<<<<<<<<<<
* elif hasmval.any():
* mask = hasmval
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3769, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_isnan); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_isnan); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3769, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
- __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_3)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_1, function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (!__pyx_t_3) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_data); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3769, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3769, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_data);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3756; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3769, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_v_mask = __pyx_t_5;
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3755
+ /* "netCDF4/_netCDF4.pyx":3768
* m = numpy.array(m)
* hasmval += data == m
* if mval.shape == () and mvalisnan: # <<<<<<<<<<<<<<
* mask = numpy.isnan(data)
* elif hasmval.any():
*/
- goto __pyx_L22;
+ goto __pyx_L17;
}
- /* "netCDF4/_netCDF4.pyx":3757
+ /* "netCDF4/_netCDF4.pyx":3770
* if mval.shape == () and mvalisnan:
* mask = numpy.isnan(data)
* elif hasmval.any(): # <<<<<<<<<<<<<<
* mask = hasmval
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_hasmval, __pyx_n_s_any); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3757; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_hasmval, __pyx_n_s_any); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3770, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__pyx_t_2 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
- __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_2)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_1, function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_2) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3757; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3770, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3757; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3770, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3757; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3770, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3758
+ /* "netCDF4/_netCDF4.pyx":3771
* mask = numpy.isnan(data)
* elif hasmval.any():
* mask = hasmval # <<<<<<<<<<<<<<
@@ -38625,17 +38512,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_hasmval);
__pyx_v_mask = __pyx_v_hasmval;
- /* "netCDF4/_netCDF4.pyx":3757
+ /* "netCDF4/_netCDF4.pyx":3770
* if mval.shape == () and mvalisnan:
* mask = numpy.isnan(data)
* elif hasmval.any(): # <<<<<<<<<<<<<<
* mask = hasmval
* else:
*/
- goto __pyx_L22;
+ goto __pyx_L17;
}
- /* "netCDF4/_netCDF4.pyx":3760
+ /* "netCDF4/_netCDF4.pyx":3773
* mask = hasmval
* else:
* mask = None # <<<<<<<<<<<<<<
@@ -38646,9 +38533,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_INCREF(Py_None);
__pyx_v_mask = Py_None;
}
- __pyx_L22:;
+ __pyx_L17:;
- /* "netCDF4/_netCDF4.pyx":3761
+ /* "netCDF4/_netCDF4.pyx":3774
* else:
* mask = None
* if mask is not None: # <<<<<<<<<<<<<<
@@ -38659,7 +38546,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_8 = (__pyx_t_9 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3762
+ /* "netCDF4/_netCDF4.pyx":3775
* mask = None
* if mask is not None:
* fill_value = mval # <<<<<<<<<<<<<<
@@ -38669,19 +38556,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_mval);
__Pyx_DECREF_SET(__pyx_v_fill_value, __pyx_v_mval);
- /* "netCDF4/_netCDF4.pyx":3763
+ /* "netCDF4/_netCDF4.pyx":3776
* if mask is not None:
* fill_value = mval
* totalmask += mask # <<<<<<<<<<<<<<
* if hasattr(self, '_FillValue'):
* fval = numpy.array(self._FillValue, self.dtype)
*/
- __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_v_totalmask, __pyx_v_mask); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3763; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_v_totalmask, __pyx_v_mask); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3776, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF_SET(__pyx_v_totalmask, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3761
+ /* "netCDF4/_netCDF4.pyx":3774
* else:
* mask = None
* if mask is not None: # <<<<<<<<<<<<<<
@@ -38690,40 +38577,40 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3738
+ /* "netCDF4/_netCDF4.pyx":3752
* totalmask = numpy.zeros(data.shape, numpy.bool)
* fill_value = None
* if hasattr(self, 'missing_value'): # <<<<<<<<<<<<<<
- * mval = numpy.array(self.missing_value, self.dtype)
- * if (self.endian() == 'big' and is_native_little) or\
+ * # note: missing_value has to have same endian-ness as variable
+ * # or this won't work.
*/
}
- /* "netCDF4/_netCDF4.pyx":3764
+ /* "netCDF4/_netCDF4.pyx":3777
* fill_value = mval
* totalmask += mask
* if hasattr(self, '_FillValue'): # <<<<<<<<<<<<<<
* fval = numpy.array(self._FillValue, self.dtype)
- * # byte swap the _FillValue if endian-ness of the variable
+ * # is _FillValue a NaN?
*/
- __pyx_t_8 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3764; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 3777, __pyx_L1_error)
__pyx_t_9 = (__pyx_t_8 != 0);
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3765
+ /* "netCDF4/_netCDF4.pyx":3778
* totalmask += mask
* if hasattr(self, '_FillValue'):
* fval = numpy.array(self._FillValue, self.dtype) # <<<<<<<<<<<<<<
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
+ * # is _FillValue a NaN?
+ * try:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3778, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3778, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3778, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__pyx_t_3 = NULL;
__pyx_t_6 = 0;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -38736,197 +38623,82 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_6 = 1;
}
}
- __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3778, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (__pyx_t_3) {
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
}
- __Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_t_1);
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_6, __pyx_t_7);
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_6, __pyx_v_self->dtype);
- __pyx_t_1 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3765; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = 0;
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3778, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_fval = __pyx_t_5;
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3768
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * fval.byteswap(True)
- */
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
- __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
- if (likely(__pyx_t_4)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
- __Pyx_INCREF(__pyx_t_4);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_2, function);
- }
- }
- if (__pyx_t_4) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- } else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- }
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_big, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (!__pyx_t_8) {
- goto __pyx_L29_next_or;
- } else {
- }
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3768; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (!__pyx_t_8) {
- } else {
- __pyx_t_9 = __pyx_t_8;
- goto __pyx_L28_bool_binop_done;
- }
- __pyx_L29_next_or:;
-
- /* "netCDF4/_netCDF4.pyx":3769
- * # is not native.
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big): # <<<<<<<<<<<<<<
- * fval.byteswap(True)
- * # is _FillValue a NaN?
- */
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
- __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
- if (likely(__pyx_t_4)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
- __Pyx_INCREF(__pyx_t_4);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_2, function);
- }
- }
- if (__pyx_t_4) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- } else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- }
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_little, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (__pyx_t_8) {
- } else {
- __pyx_t_9 = __pyx_t_8;
- goto __pyx_L28_bool_binop_done;
- }
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3769; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_9 = __pyx_t_8;
- __pyx_L28_bool_binop_done:;
-
- /* "netCDF4/_netCDF4.pyx":3768
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * fval.byteswap(True)
- */
- if (__pyx_t_9) {
-
- /* "netCDF4/_netCDF4.pyx":3770
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big):
- * fval.byteswap(True) # <<<<<<<<<<<<<<
- * # is _FillValue a NaN?
- * try:
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fval, __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3770; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3770; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
- /* "netCDF4/_netCDF4.pyx":3768
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * fval.byteswap(True)
- */
- }
-
- /* "netCDF4/_netCDF4.pyx":3772
- * fval.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":3780
+ * fval = numpy.array(self._FillValue, self.dtype)
* # is _FillValue a NaN?
* try: # <<<<<<<<<<<<<<
* fvalisnan = numpy.isnan(fval)
* except: # isnan fails on some dtypes (issue 202)
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_12, &__pyx_t_11, &__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_10);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3773
+ /* "netCDF4/_netCDF4.pyx":3781
* # is _FillValue a NaN?
* try:
* fvalisnan = numpy.isnan(fval) # <<<<<<<<<<<<<<
* except: # isnan fails on some dtypes (issue 202)
* fvalisnan = False
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3773; __pyx_clineno = __LINE__; goto __pyx_L32_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_isnan); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3773; __pyx_clineno = __LINE__; goto __pyx_L32_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3781, __pyx_L22_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isnan); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3781, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = NULL;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
- __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
- if (likely(__pyx_t_5)) {
+ __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_2)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
- __Pyx_INCREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
- if (!__pyx_t_5) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_fval); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3773; __pyx_clineno = __LINE__; goto __pyx_L32_error;}
- __Pyx_GOTREF(__pyx_t_2);
+ if (!__pyx_t_2) {
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_fval); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3781, __pyx_L22_error)
+ __Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3773; __pyx_clineno = __LINE__; goto __pyx_L32_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __pyx_t_5 = NULL;
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3781, __pyx_L22_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_fval);
__Pyx_GIVEREF(__pyx_v_fval);
- PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_v_fval);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3773; __pyx_clineno = __LINE__; goto __pyx_L32_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_fval);
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3781, __pyx_L22_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_v_fvalisnan = __pyx_t_2;
- __pyx_t_2 = 0;
+ __pyx_v_fvalisnan = __pyx_t_5;
+ __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3772
- * fval.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":3780
+ * fval = numpy.array(self._FillValue, self.dtype)
* # is _FillValue a NaN?
* try: # <<<<<<<<<<<<<<
* fvalisnan = numpy.isnan(fval)
@@ -38936,16 +38708,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
- goto __pyx_L39_try_end;
- __pyx_L32_error:;
- __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
- __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
- __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
+ goto __pyx_L29_try_end;
+ __pyx_L22_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3774
+ /* "netCDF4/_netCDF4.pyx":3782
* try:
* fvalisnan = numpy.isnan(fval)
* except: # isnan fails on some dtypes (issue 202) # <<<<<<<<<<<<<<
@@ -38954,12 +38727,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
/*except:*/ {
__Pyx_AddTraceback("netCDF4._netCDF4.Variable._toma", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3774; __pyx_clineno = __LINE__; goto __pyx_L34_except_error;}
- __Pyx_GOTREF(__pyx_t_2);
+ if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(0, 3782, __pyx_L24_except_error)
+ __Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_GOTREF(__pyx_t_7);
- /* "netCDF4/_netCDF4.pyx":3775
+ /* "netCDF4/_netCDF4.pyx":3783
* fvalisnan = numpy.isnan(fval)
* except: # isnan fails on some dtypes (issue 202)
* fvalisnan = False # <<<<<<<<<<<<<<
@@ -38968,148 +38741,150 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
__Pyx_INCREF(Py_False);
__Pyx_XDECREF_SET(__pyx_v_fvalisnan, Py_False);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- goto __pyx_L33_exception_handled;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ goto __pyx_L23_exception_handled;
}
- __pyx_L34_except_error:;
+ __pyx_L24_except_error:;
- /* "netCDF4/_netCDF4.pyx":3772
- * fval.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":3780
+ * fval = numpy.array(self._FillValue, self.dtype)
* # is _FillValue a NaN?
* try: # <<<<<<<<<<<<<<
* fvalisnan = numpy.isnan(fval)
* except: # isnan fails on some dtypes (issue 202)
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_ExceptionReset(__pyx_t_12, __pyx_t_11, __pyx_t_10);
goto __pyx_L1_error;
- __pyx_L33_exception_handled:;
+ __pyx_L23_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_ExceptionReset(__pyx_t_12, __pyx_t_11, __pyx_t_10);
- __pyx_L39_try_end:;
+ __pyx_L29_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":3776
+ /* "netCDF4/_netCDF4.pyx":3784
* except: # isnan fails on some dtypes (issue 202)
* fvalisnan = False
* if fvalisnan: # <<<<<<<<<<<<<<
* mask = numpy.isnan(data)
* elif (data == fval).any():
*/
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_fvalisnan); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3776; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_fvalisnan); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3784, __pyx_L1_error)
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3777
+ /* "netCDF4/_netCDF4.pyx":3785
* fvalisnan = False
* if fvalisnan:
* mask = numpy.isnan(data) # <<<<<<<<<<<<<<
* elif (data == fval).any():
* mask = data==fval
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3777; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3785, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isnan); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3777; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_isnan); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3785, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
- __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_4)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_2, function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (!__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_data); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3777; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_data); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3785, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3777; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3785, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
- PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_data);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3777; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_data);
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3785, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __Pyx_XDECREF_SET(__pyx_v_mask, __pyx_t_1);
- __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_XDECREF_SET(__pyx_v_mask, __pyx_t_7);
+ __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3776
+ /* "netCDF4/_netCDF4.pyx":3784
* except: # isnan fails on some dtypes (issue 202)
* fvalisnan = False
* if fvalisnan: # <<<<<<<<<<<<<<
* mask = numpy.isnan(data)
* elif (data == fval).any():
*/
- goto __pyx_L42;
+ goto __pyx_L32;
}
- /* "netCDF4/_netCDF4.pyx":3778
+ /* "netCDF4/_netCDF4.pyx":3786
* if fvalisnan:
* mask = numpy.isnan(data)
* elif (data == fval).any(): # <<<<<<<<<<<<<<
* mask = data==fval
* else:
*/
- __pyx_t_2 = PyObject_RichCompare(__pyx_v_data, __pyx_v_fval, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_any); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_2)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_2);
+ __pyx_t_5 = PyObject_RichCompare(__pyx_v_data, __pyx_v_fval, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3786, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_any); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3786, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_5 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_5)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
}
}
- if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (__pyx_t_5) {
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3786, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3786, __pyx_L1_error)
}
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3778; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3786, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3779
+ /* "netCDF4/_netCDF4.pyx":3787
* mask = numpy.isnan(data)
* elif (data == fval).any():
* mask = data==fval # <<<<<<<<<<<<<<
* else:
* mask = None
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_data, __pyx_v_fval, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3779; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_XDECREF_SET(__pyx_v_mask, __pyx_t_1);
- __pyx_t_1 = 0;
+ __pyx_t_7 = PyObject_RichCompare(__pyx_v_data, __pyx_v_fval, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3787, __pyx_L1_error)
+ __Pyx_XDECREF_SET(__pyx_v_mask, __pyx_t_7);
+ __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3778
+ /* "netCDF4/_netCDF4.pyx":3786
* if fvalisnan:
* mask = numpy.isnan(data)
* elif (data == fval).any(): # <<<<<<<<<<<<<<
* mask = data==fval
* else:
*/
- goto __pyx_L42;
+ goto __pyx_L32;
}
- /* "netCDF4/_netCDF4.pyx":3781
+ /* "netCDF4/_netCDF4.pyx":3789
* mask = data==fval
* else:
* mask = None # <<<<<<<<<<<<<<
@@ -39120,9 +38895,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_INCREF(Py_None);
__Pyx_XDECREF_SET(__pyx_v_mask, Py_None);
}
- __pyx_L42:;
+ __pyx_L32:;
- /* "netCDF4/_netCDF4.pyx":3782
+ /* "netCDF4/_netCDF4.pyx":3790
* else:
* mask = None
* if mask is not None: # <<<<<<<<<<<<<<
@@ -39133,7 +38908,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_8 = (__pyx_t_9 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3783
+ /* "netCDF4/_netCDF4.pyx":3791
* mask = None
* if mask is not None:
* if fill_value is None: # <<<<<<<<<<<<<<
@@ -39144,7 +38919,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_9 = (__pyx_t_8 != 0);
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3784
+ /* "netCDF4/_netCDF4.pyx":3792
* if mask is not None:
* if fill_value is None:
* fill_value = fval # <<<<<<<<<<<<<<
@@ -39154,7 +38929,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_fval);
__Pyx_DECREF_SET(__pyx_v_fill_value, __pyx_v_fval);
- /* "netCDF4/_netCDF4.pyx":3783
+ /* "netCDF4/_netCDF4.pyx":3791
* mask = None
* if mask is not None:
* if fill_value is None: # <<<<<<<<<<<<<<
@@ -39163,19 +38938,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3785
+ /* "netCDF4/_netCDF4.pyx":3793
* if fill_value is None:
* fill_value = fval
* totalmask += mask # <<<<<<<<<<<<<<
* # issue 209: don't return masked array if variable filling
* # is disabled.
*/
- __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_totalmask, __pyx_v_mask); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3785; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF_SET(__pyx_v_totalmask, __pyx_t_1);
- __pyx_t_1 = 0;
+ __pyx_t_7 = PyNumber_InPlaceAdd(__pyx_v_totalmask, __pyx_v_mask); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3793, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF_SET(__pyx_v_totalmask, __pyx_t_7);
+ __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3782
+ /* "netCDF4/_netCDF4.pyx":3790
* else:
* mask = None
* if mask is not None: # <<<<<<<<<<<<<<
@@ -39184,17 +38959,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3764
+ /* "netCDF4/_netCDF4.pyx":3777
* fill_value = mval
* totalmask += mask
* if hasattr(self, '_FillValue'): # <<<<<<<<<<<<<<
* fval = numpy.array(self._FillValue, self.dtype)
- * # byte swap the _FillValue if endian-ness of the variable
+ * # is _FillValue a NaN?
*/
- goto __pyx_L26;
+ goto __pyx_L21;
}
- /* "netCDF4/_netCDF4.pyx":3789
+ /* "netCDF4/_netCDF4.pyx":3797
* # is disabled.
* else:
* with nogil: # <<<<<<<<<<<<<<
@@ -39209,7 +38984,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":3790
+ /* "netCDF4/_netCDF4.pyx":3798
* else:
* with nogil:
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL) # <<<<<<<<<<<<<<
@@ -39219,7 +38994,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_v_ierr = nc_inq_var_fill(__pyx_v_self->_grpid, __pyx_v_self->_varid, (&__pyx_v_no_fill), NULL);
}
- /* "netCDF4/_netCDF4.pyx":3789
+ /* "netCDF4/_netCDF4.pyx":3797
* # is disabled.
* else:
* with nogil: # <<<<<<<<<<<<<<
@@ -39231,13 +39006,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
#ifdef WITH_THREAD
Py_BLOCK_THREADS
#endif
- goto __pyx_L47;
+ goto __pyx_L37;
}
- __pyx_L47:;
+ __pyx_L37:;
}
}
- /* "netCDF4/_netCDF4.pyx":3791
+ /* "netCDF4/_netCDF4.pyx":3799
* with nogil:
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -39247,7 +39022,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_9 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3792
+ /* "netCDF4/_netCDF4.pyx":3800
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -39255,22 +39030,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
* # from http://www.unidata.ucar.edu/software/netcdf/docs/netcdf-c/Fill-Values.html#Fill-Values
*/
__pyx_t_15 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_15, 0, strlen(__pyx_t_15), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3792; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3792; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_1);
- __Pyx_GIVEREF(__pyx_t_1);
- PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3792; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_Raise(__pyx_t_1, 0, 0, 0);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3792; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_15, 0, strlen(__pyx_t_15), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3800, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3800, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_7);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3800, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_Raise(__pyx_t_7, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __PYX_ERR(0, 3800, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3791
+ /* "netCDF4/_netCDF4.pyx":3799
* with nogil:
* ierr = nc_inq_var_fill(self._grpid,self._varid,&no_fill,NULL)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -39279,308 +39054,191 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3805
+ /* "netCDF4/_netCDF4.pyx":3813
* # small to assume one of the values should appear as a missing
* # value unless a _FillValue attribute is set explicitly."
* if no_fill != 1 and self.dtype.str[1:] not in ['u1','i1']: # <<<<<<<<<<<<<<
* fillval = numpy.array(default_fillvals[self.dtype.str[1:]],self.dtype)
- * # byte swap the _FillValue if endian-ness of the variable
+ * has_fillval = data == fillval
*/
__pyx_t_8 = ((__pyx_v_no_fill != 1) != 0);
if (__pyx_t_8) {
} else {
__pyx_t_9 = __pyx_t_8;
- goto __pyx_L50_bool_binop_done;
+ goto __pyx_L40_bool_binop_done;
}
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_t_1, 1, 0, NULL, NULL, &__pyx_slice__57, 1, 0, 1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_16 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_u1, Py_NE)); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3813, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = __Pyx_PyObject_GetSlice(__pyx_t_7, 1, 0, NULL, NULL, &__pyx_slice__56, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3813, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_16 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_u1, Py_NE)); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 3813, __pyx_L1_error)
if (__pyx_t_16) {
} else {
__pyx_t_8 = __pyx_t_16;
- goto __pyx_L52_bool_binop_done;
+ goto __pyx_L42_bool_binop_done;
}
- __pyx_t_16 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_i1, Py_NE)); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_16 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_i1, Py_NE)); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 3813, __pyx_L1_error)
__pyx_t_8 = __pyx_t_16;
- __pyx_L52_bool_binop_done:;
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_L42_bool_binop_done:;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_16 = (__pyx_t_8 != 0);
__pyx_t_9 = __pyx_t_16;
- __pyx_L50_bool_binop_done:;
+ __pyx_L40_bool_binop_done:;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3806
+ /* "netCDF4/_netCDF4.pyx":3814
* # value unless a _FillValue attribute is set explicitly."
* if no_fill != 1 and self.dtype.str[1:] not in ['u1','i1']:
* fillval = numpy.array(default_fillvals[self.dtype.str[1:]],self.dtype) # <<<<<<<<<<<<<<
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
+ * has_fillval = data == fillval
+ * # if data is an array scalar, has_fillval will be a boolean.
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_fillvals); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_fillvals); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3814, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_4, 1, 0, NULL, NULL, &__pyx_slice__58, 1, 0, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_4, 1, 0, NULL, NULL, &__pyx_slice__57, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3814, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyObject_GetItem(__pyx_t_1, __pyx_t_3); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3814, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
__pyx_t_6 = 0;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
- __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_3)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_2, function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
__pyx_t_6 = 1;
}
}
- __pyx_t_1 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_3) {
- __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); __pyx_t_3 = NULL;
+ __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
}
__Pyx_GIVEREF(__pyx_t_4);
- PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_6, __pyx_t_4);
+ PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_4);
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
- PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_6, __pyx_v_self->dtype);
+ PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_self->dtype);
__pyx_t_4 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_v_fillval = __pyx_t_5;
- __pyx_t_5 = 0;
-
- /* "netCDF4/_netCDF4.pyx":3809
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * fillval.byteswap(True)
- */
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
- __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
- if (likely(__pyx_t_1)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
- __Pyx_INCREF(__pyx_t_1);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_2, function);
- }
- }
- if (__pyx_t_1) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- } else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- }
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_16 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_big, Py_EQ)); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (!__pyx_t_16) {
- goto __pyx_L56_next_or;
- } else {
- }
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3809; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (!__pyx_t_16) {
- } else {
- __pyx_t_9 = __pyx_t_16;
- goto __pyx_L55_bool_binop_done;
- }
- __pyx_L56_next_or:;
-
- /* "netCDF4/_netCDF4.pyx":3810
- * # is not native.
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big): # <<<<<<<<<<<<<<
- * fillval.byteswap(True)
- * has_fillval = data == fillval
- */
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3814, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
- __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
- if (likely(__pyx_t_1)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
- __Pyx_INCREF(__pyx_t_1);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_2, function);
- }
- }
- if (__pyx_t_1) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- } else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- }
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_16 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_little, Py_EQ)); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (__pyx_t_16) {
- } else {
- __pyx_t_9 = __pyx_t_16;
- goto __pyx_L55_bool_binop_done;
- }
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_9 = __pyx_t_16;
- __pyx_L55_bool_binop_done:;
-
- /* "netCDF4/_netCDF4.pyx":3809
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * fillval.byteswap(True)
- */
- if (__pyx_t_9) {
-
- /* "netCDF4/_netCDF4.pyx":3811
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big):
- * fillval.byteswap(True) # <<<<<<<<<<<<<<
- * has_fillval = data == fillval
- * # if data is an array scalar, has_fillval will be a boolean.
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_fillval, __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3811; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3811; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
-
- /* "netCDF4/_netCDF4.pyx":3809
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
- * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
- * (self.endian() == 'little' and is_native_big):
- * fillval.byteswap(True)
- */
- }
+ __pyx_v_fillval = __pyx_t_2;
+ __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3812
- * (self.endian() == 'little' and is_native_big):
- * fillval.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":3815
+ * if no_fill != 1 and self.dtype.str[1:] not in ['u1','i1']:
+ * fillval = numpy.array(default_fillvals[self.dtype.str[1:]],self.dtype)
* has_fillval = data == fillval # <<<<<<<<<<<<<<
* # if data is an array scalar, has_fillval will be a boolean.
* # in that case convert to an array.
*/
- __pyx_t_2 = PyObject_RichCompare(__pyx_v_data, __pyx_v_fillval, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3812; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_v_data, __pyx_v_fillval, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3815, __pyx_L1_error)
__pyx_v_has_fillval = __pyx_t_2;
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3815
+ /* "netCDF4/_netCDF4.pyx":3818
* # if data is an array scalar, has_fillval will be a boolean.
* # in that case convert to an array.
* if type(has_fillval) == bool: has_fillval=numpy.asarray(has_fillval) # <<<<<<<<<<<<<<
* if has_fillval.any():
* mask=data==fillval
*/
- __pyx_t_2 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_has_fillval)), ((PyObject*)&PyBool_Type), Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_has_fillval)), ((PyObject*)&PyBool_Type), Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3818, __pyx_L1_error)
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3818, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_9) {
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3818, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_asarray); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_asarray); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3818, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
- __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1);
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_5)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_1, function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (!__pyx_t_5) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_has_fillval); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_has_fillval); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3818, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3818, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_has_fillval);
__Pyx_GIVEREF(__pyx_v_has_fillval);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_has_fillval);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3818, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF_SET(__pyx_v_has_fillval, __pyx_t_2);
__pyx_t_2 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3816
+ /* "netCDF4/_netCDF4.pyx":3819
* # in that case convert to an array.
* if type(has_fillval) == bool: has_fillval=numpy.asarray(has_fillval)
* if has_fillval.any(): # <<<<<<<<<<<<<<
* mask=data==fillval
* if fill_value is None:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_has_fillval, __pyx_n_s_any); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3816; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_has_fillval, __pyx_n_s_any); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3819, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__pyx_t_4 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
- __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1);
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_4)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_1, function);
+ __Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3816; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3819, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3816; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3819, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3816; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 3819, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3817
+ /* "netCDF4/_netCDF4.pyx":3820
* if type(has_fillval) == bool: has_fillval=numpy.asarray(has_fillval)
* if has_fillval.any():
* mask=data==fillval # <<<<<<<<<<<<<<
* if fill_value is None:
* fill_value = fillval
*/
- __pyx_t_2 = PyObject_RichCompare(__pyx_v_data, __pyx_v_fillval, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3817; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_v_data, __pyx_v_fillval, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3820, __pyx_L1_error)
__Pyx_XDECREF_SET(__pyx_v_mask, __pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3818
+ /* "netCDF4/_netCDF4.pyx":3821
* if has_fillval.any():
* mask=data==fillval
* if fill_value is None: # <<<<<<<<<<<<<<
@@ -39591,7 +39249,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_16 = (__pyx_t_9 != 0);
if (__pyx_t_16) {
- /* "netCDF4/_netCDF4.pyx":3819
+ /* "netCDF4/_netCDF4.pyx":3822
* mask=data==fillval
* if fill_value is None:
* fill_value = fillval # <<<<<<<<<<<<<<
@@ -39601,7 +39259,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_fillval);
__Pyx_DECREF_SET(__pyx_v_fill_value, __pyx_v_fillval);
- /* "netCDF4/_netCDF4.pyx":3818
+ /* "netCDF4/_netCDF4.pyx":3821
* if has_fillval.any():
* mask=data==fillval
* if fill_value is None: # <<<<<<<<<<<<<<
@@ -39610,19 +39268,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3820
+ /* "netCDF4/_netCDF4.pyx":3823
* if fill_value is None:
* fill_value = fillval
* totalmask += mask # <<<<<<<<<<<<<<
* # all values where data == missing_value or _FillValue are
* # masked. fill_value set to missing_value if it exists,
*/
- __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_totalmask, __pyx_v_mask); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3820; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_totalmask, __pyx_v_mask); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3823, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF_SET(__pyx_v_totalmask, __pyx_t_2);
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3816
+ /* "netCDF4/_netCDF4.pyx":3819
* # in that case convert to an array.
* if type(has_fillval) == bool: has_fillval=numpy.asarray(has_fillval)
* if has_fillval.any(): # <<<<<<<<<<<<<<
@@ -39631,18 +39289,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3805
+ /* "netCDF4/_netCDF4.pyx":3813
* # small to assume one of the values should appear as a missing
* # value unless a _FillValue attribute is set explicitly."
* if no_fill != 1 and self.dtype.str[1:] not in ['u1','i1']: # <<<<<<<<<<<<<<
* fillval = numpy.array(default_fillvals[self.dtype.str[1:]],self.dtype)
- * # byte swap the _FillValue if endian-ness of the variable
+ * has_fillval = data == fillval
*/
}
}
- __pyx_L26:;
+ __pyx_L21:;
- /* "netCDF4/_netCDF4.pyx":3824
+ /* "netCDF4/_netCDF4.pyx":3827
* # masked. fill_value set to missing_value if it exists,
* # otherwise _FillValue.
* if fill_value is not None: # <<<<<<<<<<<<<<
@@ -39653,56 +39311,56 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_t_9 = (__pyx_t_16 != 0);
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3825
+ /* "netCDF4/_netCDF4.pyx":3828
* # otherwise _FillValue.
* if fill_value is not None:
* data = ma.masked_array(data,mask=totalmask,fill_value=fill_value) # <<<<<<<<<<<<<<
* # issue 515 scalar array with mask=True should be converted
* # to numpy.ma.MaskedConstant to be consistent with slicing
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_masked_array); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_masked_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3828, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_data);
- __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_mask, __pyx_v_totalmask) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_fill_value, __pyx_v_fill_value) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3825; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_mask, __pyx_v_totalmask) < 0) __PYX_ERR(0, 3828, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_fill_value, __pyx_v_fill_value) < 0) __PYX_ERR(0, 3828, __pyx_L1_error)
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3828, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3829
+ /* "netCDF4/_netCDF4.pyx":3832
* # to numpy.ma.MaskedConstant to be consistent with slicing
* # behavior of masked arrays.
* if data.shape == () and data.mask.all(): # <<<<<<<<<<<<<<
* data = data[...]
* return data
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3829; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3832, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3829; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3832, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3829; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 3832, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_16) {
} else {
__pyx_t_9 = __pyx_t_16;
- goto __pyx_L64_bool_binop_done;
+ goto __pyx_L49_bool_binop_done;
}
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_mask); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3829; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_mask); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3832, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_all); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3829; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_all); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3832, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = NULL;
@@ -39716,32 +39374,32 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
}
}
if (__pyx_t_5) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3829; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3832, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3829; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3832, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3829; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 3832, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_9 = __pyx_t_16;
- __pyx_L64_bool_binop_done:;
+ __pyx_L49_bool_binop_done:;
if (__pyx_t_9) {
- /* "netCDF4/_netCDF4.pyx":3830
+ /* "netCDF4/_netCDF4.pyx":3833
* # behavior of masked arrays.
* if data.shape == () and data.mask.all():
* data = data[...] # <<<<<<<<<<<<<<
* return data
*
*/
- __pyx_t_4 = PyObject_GetItem(__pyx_v_data, Py_Ellipsis); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3830; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_data, Py_Ellipsis); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3833, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":3829
+ /* "netCDF4/_netCDF4.pyx":3832
* # to numpy.ma.MaskedConstant to be consistent with slicing
* # behavior of masked arrays.
* if data.shape == () and data.mask.all(): # <<<<<<<<<<<<<<
@@ -39750,7 +39408,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3824
+ /* "netCDF4/_netCDF4.pyx":3827
* # masked. fill_value set to missing_value if it exists,
* # otherwise _FillValue.
* if fill_value is not None: # <<<<<<<<<<<<<<
@@ -39759,7 +39417,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3831
+ /* "netCDF4/_netCDF4.pyx":3834
* if data.shape == () and data.mask.all():
* data = data[...]
* return data # <<<<<<<<<<<<<<
@@ -39771,7 +39429,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
__pyx_r = __pyx_v_data;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3732
+ /* "netCDF4/_netCDF4.pyx":3746
* return data
*
* def _toma(self,data): # <<<<<<<<<<<<<<
@@ -39807,7 +39465,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_46_toma(struct __pyx_obj_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3833
+/* "netCDF4/_netCDF4.pyx":3836
* return data
*
* def _assign_vlen(self, elem, data): # <<<<<<<<<<<<<<
@@ -39821,9 +39479,6 @@ static char __pyx_doc_7netCDF4_8_netCDF4_8Variable_48_assign_vlen[] = "private m
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_49_assign_vlen(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_elem = 0;
PyObject *__pyx_v_data = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_assign_vlen (wrapper)", 0);
@@ -39847,11 +39502,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_49_assign_vlen(PyObject *
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("_assign_vlen", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3833; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_assign_vlen", 1, 2, 2, 1); __PYX_ERR(0, 3836, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_assign_vlen") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3833; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_assign_vlen") < 0)) __PYX_ERR(0, 3836, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -39864,7 +39519,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_49_assign_vlen(PyObject *
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("_assign_vlen", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3833; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_assign_vlen", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 3836, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Variable._assign_vlen", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -39906,37 +39561,34 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
int __pyx_t_9;
size_t __pyx_t_10;
char *__pyx_t_11;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_assign_vlen", 0);
__Pyx_INCREF(__pyx_v_elem);
- /* "netCDF4/_netCDF4.pyx":3841
+ /* "netCDF4/_netCDF4.pyx":3844
* cdef char **strdata
* cdef ndarray data2
* if not self._isvlen: # <<<<<<<<<<<<<<
* raise TypeError('_assign_vlen method only for use with VLEN variables')
* ndims = self.ndim
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3841; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3844, __pyx_L1_error)
__pyx_t_2 = ((!__pyx_t_1) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3842
+ /* "netCDF4/_netCDF4.pyx":3845
* cdef ndarray data2
* if not self._isvlen:
* raise TypeError('_assign_vlen method only for use with VLEN variables') # <<<<<<<<<<<<<<
* ndims = self.ndim
* msg="data can only be assigned to VLEN variables using integer indices"
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3842; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3845, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3842; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3845, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3841
+ /* "netCDF4/_netCDF4.pyx":3844
* cdef char **strdata
* cdef ndarray data2
* if not self._isvlen: # <<<<<<<<<<<<<<
@@ -39945,17 +39597,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3843
+ /* "netCDF4/_netCDF4.pyx":3846
* if not self._isvlen:
* raise TypeError('_assign_vlen method only for use with VLEN variables')
* ndims = self.ndim # <<<<<<<<<<<<<<
* msg="data can only be assigned to VLEN variables using integer indices"
* # check to see that elem is a tuple of integers.
*/
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_self->ndim); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3843; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_v_self->ndim); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3846, __pyx_L1_error)
__pyx_v_ndims = __pyx_t_4;
- /* "netCDF4/_netCDF4.pyx":3844
+ /* "netCDF4/_netCDF4.pyx":3847
* raise TypeError('_assign_vlen method only for use with VLEN variables')
* ndims = self.ndim
* msg="data can only be assigned to VLEN variables using integer indices" # <<<<<<<<<<<<<<
@@ -39965,7 +39617,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__Pyx_INCREF(__pyx_kp_s_data_can_only_be_assigned_to_VLE);
__pyx_v_msg = __pyx_kp_s_data_can_only_be_assigned_to_VLE;
- /* "netCDF4/_netCDF4.pyx":3847
+ /* "netCDF4/_netCDF4.pyx":3850
* # check to see that elem is a tuple of integers.
* # handle negative integers.
* if isinstance(elem, int): # <<<<<<<<<<<<<<
@@ -39976,7 +39628,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3848
+ /* "netCDF4/_netCDF4.pyx":3851
* # handle negative integers.
* if isinstance(elem, int):
* if ndims > 1: # <<<<<<<<<<<<<<
@@ -39986,26 +39638,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_1 = ((__pyx_v_ndims > 1) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3849
+ /* "netCDF4/_netCDF4.pyx":3852
* if isinstance(elem, int):
* if ndims > 1:
* raise IndexError(msg) # <<<<<<<<<<<<<<
* if elem < 0:
* if self.shape[0]+elem >= 0:
*/
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3849; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3852, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_msg);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3849; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3852, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3849; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3852, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3848
+ /* "netCDF4/_netCDF4.pyx":3851
* # handle negative integers.
* if isinstance(elem, int):
* if ndims > 1: # <<<<<<<<<<<<<<
@@ -40014,58 +39666,58 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3850
+ /* "netCDF4/_netCDF4.pyx":3853
* if ndims > 1:
* raise IndexError(msg)
* if elem < 0: # <<<<<<<<<<<<<<
* if self.shape[0]+elem >= 0:
* elem = self.shape[0]+elem
*/
- __pyx_t_5 = PyObject_RichCompare(__pyx_v_elem, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3850; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3850; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_RichCompare(__pyx_v_elem, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3853, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3853, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3851
+ /* "netCDF4/_netCDF4.pyx":3854
* raise IndexError(msg)
* if elem < 0:
* if self.shape[0]+elem >= 0: # <<<<<<<<<<<<<<
* elem = self.shape[0]+elem
* else:
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3851; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3854, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3851; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_5, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3854, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyNumber_Add(__pyx_t_3, __pyx_v_elem); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3851; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyNumber_Add(__pyx_t_3, __pyx_v_elem); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3854, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3851; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_5, __pyx_int_0, Py_GE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3854, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3851; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3854, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3852
+ /* "netCDF4/_netCDF4.pyx":3855
* if elem < 0:
* if self.shape[0]+elem >= 0:
* elem = self.shape[0]+elem # <<<<<<<<<<<<<<
* else:
* raise IndexError("Illegal index")
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3855, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3852; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3855, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_v_elem); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Add(__pyx_t_5, __pyx_v_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3855, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF_SET(__pyx_v_elem, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3851
+ /* "netCDF4/_netCDF4.pyx":3854
* raise IndexError(msg)
* if elem < 0:
* if self.shape[0]+elem >= 0: # <<<<<<<<<<<<<<
@@ -40075,7 +39727,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
goto __pyx_L7;
}
- /* "netCDF4/_netCDF4.pyx":3854
+ /* "netCDF4/_netCDF4.pyx":3857
* elem = self.shape[0]+elem
* else:
* raise IndexError("Illegal index") # <<<<<<<<<<<<<<
@@ -40083,15 +39735,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
* if len(elem) != ndims:
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3854; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3857, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3854; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3857, __pyx_L1_error)
}
__pyx_L7:;
- /* "netCDF4/_netCDF4.pyx":3850
+ /* "netCDF4/_netCDF4.pyx":3853
* if ndims > 1:
* raise IndexError(msg)
* if elem < 0: # <<<<<<<<<<<<<<
@@ -40100,7 +39752,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3847
+ /* "netCDF4/_netCDF4.pyx":3850
* # check to see that elem is a tuple of integers.
* # handle negative integers.
* if isinstance(elem, int): # <<<<<<<<<<<<<<
@@ -40110,7 +39762,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
goto __pyx_L4;
}
- /* "netCDF4/_netCDF4.pyx":3855
+ /* "netCDF4/_netCDF4.pyx":3858
* else:
* raise IndexError("Illegal index")
* elif isinstance(elem, tuple): # <<<<<<<<<<<<<<
@@ -40121,31 +39773,31 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3856
+ /* "netCDF4/_netCDF4.pyx":3859
* raise IndexError("Illegal index")
* elif isinstance(elem, tuple):
* if len(elem) != ndims: # <<<<<<<<<<<<<<
* raise IndexError("Illegal index")
* elemnew = []
*/
- __pyx_t_6 = PyObject_Length(__pyx_v_elem); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3856; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_Length(__pyx_v_elem); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 3859, __pyx_L1_error)
__pyx_t_2 = ((__pyx_t_6 != __pyx_v_ndims) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3857
+ /* "netCDF4/_netCDF4.pyx":3860
* elif isinstance(elem, tuple):
* if len(elem) != ndims:
* raise IndexError("Illegal index") # <<<<<<<<<<<<<<
* elemnew = []
* for n,e in enumerate(elem):
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3857; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3860, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3857; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3860, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3856
+ /* "netCDF4/_netCDF4.pyx":3859
* raise IndexError("Illegal index")
* elif isinstance(elem, tuple):
* if len(elem) != ndims: # <<<<<<<<<<<<<<
@@ -40154,19 +39806,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3858
+ /* "netCDF4/_netCDF4.pyx":3861
* if len(elem) != ndims:
* raise IndexError("Illegal index")
* elemnew = [] # <<<<<<<<<<<<<<
* for n,e in enumerate(elem):
* if not isinstance(e, int):
*/
- __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3858; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3861, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_elemnew = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3859
+ /* "netCDF4/_netCDF4.pyx":3862
* raise IndexError("Illegal index")
* elemnew = []
* for n,e in enumerate(elem): # <<<<<<<<<<<<<<
@@ -40178,26 +39830,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_3 = __pyx_v_elem; __Pyx_INCREF(__pyx_t_3); __pyx_t_6 = 0;
__pyx_t_7 = NULL;
} else {
- __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_elem); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3859; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3859; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3862, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_7)) {
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3859; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3862, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3859; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
} else {
if (__pyx_t_6 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3859; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_6); __Pyx_INCREF(__pyx_t_5); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(0, 3862, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3859; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
}
@@ -40207,7 +39859,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3859; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3862, __pyx_L1_error)
}
break;
}
@@ -40218,7 +39870,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_v_n = __pyx_t_4;
__pyx_t_4 = (__pyx_t_4 + 1);
- /* "netCDF4/_netCDF4.pyx":3860
+ /* "netCDF4/_netCDF4.pyx":3863
* elemnew = []
* for n,e in enumerate(elem):
* if not isinstance(e, int): # <<<<<<<<<<<<<<
@@ -40229,26 +39881,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3861
+ /* "netCDF4/_netCDF4.pyx":3864
* for n,e in enumerate(elem):
* if not isinstance(e, int):
* raise IndexError(msg) # <<<<<<<<<<<<<<
* elif e < 0:
* enew = self.shape[n]+e
*/
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3861; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3864, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_msg);
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3861; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3864, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3861; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3864, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3860
+ /* "netCDF4/_netCDF4.pyx":3863
* elemnew = []
* for n,e in enumerate(elem):
* if not isinstance(e, int): # <<<<<<<<<<<<<<
@@ -40257,62 +39909,62 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3862
+ /* "netCDF4/_netCDF4.pyx":3865
* if not isinstance(e, int):
* raise IndexError(msg)
* elif e < 0: # <<<<<<<<<<<<<<
* enew = self.shape[n]+e
* if enew < 0:
*/
- __pyx_t_8 = PyObject_RichCompare(__pyx_v_e, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3862; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3862; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_RichCompare(__pyx_v_e, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3865, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3865, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3863
+ /* "netCDF4/_netCDF4.pyx":3866
* raise IndexError(msg)
* elif e < 0:
* enew = self.shape[n]+e # <<<<<<<<<<<<<<
* if enew < 0:
* raise IndexError("Illegal index")
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3863; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3866, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, __pyx_v_n, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3863; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, __pyx_v_n, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3866, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = PyNumber_Add(__pyx_t_5, __pyx_v_e); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3863; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyNumber_Add(__pyx_t_5, __pyx_v_e); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3866, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF_SET(__pyx_v_enew, __pyx_t_8);
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":3864
+ /* "netCDF4/_netCDF4.pyx":3867
* elif e < 0:
* enew = self.shape[n]+e
* if enew < 0: # <<<<<<<<<<<<<<
* raise IndexError("Illegal index")
* else:
*/
- __pyx_t_8 = PyObject_RichCompare(__pyx_v_enew, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_RichCompare(__pyx_v_enew, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3867, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3867, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3865
+ /* "netCDF4/_netCDF4.pyx":3868
* enew = self.shape[n]+e
* if enew < 0:
* raise IndexError("Illegal index") # <<<<<<<<<<<<<<
* else:
* elemnew.append(self.shape[n]+e)
*/
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3865; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3868, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3865; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3868, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3864
+ /* "netCDF4/_netCDF4.pyx":3867
* elif e < 0:
* enew = self.shape[n]+e
* if enew < 0: # <<<<<<<<<<<<<<
@@ -40321,7 +39973,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3867
+ /* "netCDF4/_netCDF4.pyx":3870
* raise IndexError("Illegal index")
* else:
* elemnew.append(self.shape[n]+e) # <<<<<<<<<<<<<<
@@ -40329,19 +39981,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
* elemnew.append(e)
*/
/*else*/ {
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3870, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, __pyx_v_n, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3867; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_8, __pyx_v_n, int, 1, __Pyx_PyInt_From_int, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3870, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = PyNumber_Add(__pyx_t_5, __pyx_v_e); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyNumber_Add(__pyx_t_5, __pyx_v_e); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3870, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_elemnew, __pyx_t_8); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_elemnew, __pyx_t_8); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 3870, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
- /* "netCDF4/_netCDF4.pyx":3862
+ /* "netCDF4/_netCDF4.pyx":3865
* if not isinstance(e, int):
* raise IndexError(msg)
* elif e < 0: # <<<<<<<<<<<<<<
@@ -40351,7 +40003,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
goto __pyx_L11;
}
- /* "netCDF4/_netCDF4.pyx":3869
+ /* "netCDF4/_netCDF4.pyx":3872
* elemnew.append(self.shape[n]+e)
* else:
* elemnew.append(e) # <<<<<<<<<<<<<<
@@ -40359,11 +40011,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
* else:
*/
/*else*/ {
- __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_elemnew, __pyx_v_e); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3869; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_elemnew, __pyx_v_e); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 3872, __pyx_L1_error)
}
__pyx_L11:;
- /* "netCDF4/_netCDF4.pyx":3859
+ /* "netCDF4/_netCDF4.pyx":3862
* raise IndexError("Illegal index")
* elemnew = []
* for n,e in enumerate(elem): # <<<<<<<<<<<<<<
@@ -40373,19 +40025,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3870
+ /* "netCDF4/_netCDF4.pyx":3873
* else:
* elemnew.append(e)
* elem = tuple(elemnew) # <<<<<<<<<<<<<<
* else:
* raise IndexError(msg)
*/
- __pyx_t_3 = PyList_AsTuple(__pyx_v_elemnew); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3870; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_AsTuple(__pyx_v_elemnew); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3873, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF_SET(__pyx_v_elem, __pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3855
+ /* "netCDF4/_netCDF4.pyx":3858
* else:
* raise IndexError("Illegal index")
* elif isinstance(elem, tuple): # <<<<<<<<<<<<<<
@@ -40395,7 +40047,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
goto __pyx_L4;
}
- /* "netCDF4/_netCDF4.pyx":3872
+ /* "netCDF4/_netCDF4.pyx":3875
* elem = tuple(elemnew)
* else:
* raise IndexError(msg) # <<<<<<<<<<<<<<
@@ -40403,21 +40055,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
* if isinstance(elem, tuple):
*/
/*else*/ {
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3872; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3875, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_msg);
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3872; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3875, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3872; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3875, __pyx_L1_error)
}
__pyx_L4:;
- /* "netCDF4/_netCDF4.pyx":3874
+ /* "netCDF4/_netCDF4.pyx":3877
* raise IndexError(msg)
* # set start, count
* if isinstance(elem, tuple): # <<<<<<<<<<<<<<
@@ -40428,19 +40080,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3875
+ /* "netCDF4/_netCDF4.pyx":3878
* # set start, count
* if isinstance(elem, tuple):
* start = list(elem) # <<<<<<<<<<<<<<
* else:
* start = [elem]
*/
- __pyx_t_8 = PySequence_List(__pyx_v_elem); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_List(__pyx_v_elem); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3878, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_v_start = ((PyObject*)__pyx_t_8);
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":3874
+ /* "netCDF4/_netCDF4.pyx":3877
* raise IndexError(msg)
* # set start, count
* if isinstance(elem, tuple): # <<<<<<<<<<<<<<
@@ -40450,7 +40102,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
goto __pyx_L13;
}
- /* "netCDF4/_netCDF4.pyx":3877
+ /* "netCDF4/_netCDF4.pyx":3880
* start = list(elem)
* else:
* start = [elem] # <<<<<<<<<<<<<<
@@ -40458,7 +40110,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
*/
/*else*/ {
- __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3877; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyList_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3880, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_v_elem);
__Pyx_GIVEREF(__pyx_v_elem);
@@ -40468,14 +40120,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
}
__pyx_L13:;
- /* "netCDF4/_netCDF4.pyx":3878
+ /* "netCDF4/_netCDF4.pyx":3881
* else:
* start = [elem]
* count = [1]*ndims # <<<<<<<<<<<<<<
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
*/
- __pyx_t_8 = PyList_New(1 * ((__pyx_v_ndims<0) ? 0:__pyx_v_ndims)); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3878; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyList_New(1 * ((__pyx_v_ndims<0) ? 0:__pyx_v_ndims)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3881, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
{ Py_ssize_t __pyx_temp;
for (__pyx_temp=0; __pyx_temp < __pyx_v_ndims; __pyx_temp++) {
@@ -40487,7 +40139,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_v_count = ((PyObject*)__pyx_t_8);
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":3879
+ /* "netCDF4/_netCDF4.pyx":3882
* start = [elem]
* count = [1]*ndims
* startp = <size_t *>malloc(sizeof(size_t) * ndims) # <<<<<<<<<<<<<<
@@ -40496,7 +40148,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
__pyx_v_startp = ((size_t *)malloc(((sizeof(size_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":3880
+ /* "netCDF4/_netCDF4.pyx":3883
* count = [1]*ndims
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims) # <<<<<<<<<<<<<<
@@ -40505,7 +40157,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
__pyx_v_countp = ((size_t *)malloc(((sizeof(size_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":3881
+ /* "netCDF4/_netCDF4.pyx":3884
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
* for n from 0 <= n < ndims: # <<<<<<<<<<<<<<
@@ -40515,46 +40167,46 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_4 = __pyx_v_ndims;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_4; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":3882
+ /* "netCDF4/_netCDF4.pyx":3885
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
* for n from 0 <= n < ndims:
* startp[n] = start[n] # <<<<<<<<<<<<<<
* countp[n] = count[n]
* if self.dtype == str: # VLEN string
*/
- __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_start, __pyx_v_n, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3882; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_start, __pyx_v_n, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3885, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_t_8); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3882; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_t_8); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3885, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
(__pyx_v_startp[__pyx_v_n]) = __pyx_t_10;
- /* "netCDF4/_netCDF4.pyx":3883
+ /* "netCDF4/_netCDF4.pyx":3886
* for n from 0 <= n < ndims:
* startp[n] = start[n]
* countp[n] = count[n] # <<<<<<<<<<<<<<
* if self.dtype == str: # VLEN string
* strdata = <char **>malloc(sizeof(char *))
*/
- __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_count, __pyx_v_n, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3883; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_8 = __Pyx_GetItemInt_List(__pyx_v_count, __pyx_v_n, int, 1, __Pyx_PyInt_From_int, 1, 1, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3886, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_t_8); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3883; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_As_size_t(__pyx_t_8); if (unlikely((__pyx_t_10 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 3886, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
(__pyx_v_countp[__pyx_v_n]) = __pyx_t_10;
}
- /* "netCDF4/_netCDF4.pyx":3884
+ /* "netCDF4/_netCDF4.pyx":3887
* startp[n] = start[n]
* countp[n] = count[n]
* if self.dtype == str: # VLEN string # <<<<<<<<<<<<<<
* strdata = <char **>malloc(sizeof(char *))
* bytestr = _strencode(data)
*/
- __pyx_t_8 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3884; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3884; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3887, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3887, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3885
+ /* "netCDF4/_netCDF4.pyx":3888
* countp[n] = count[n]
* if self.dtype == str: # VLEN string
* strdata = <char **>malloc(sizeof(char *)) # <<<<<<<<<<<<<<
@@ -40563,29 +40215,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
__pyx_v_strdata = ((char **)malloc((sizeof(char *))));
- /* "netCDF4/_netCDF4.pyx":3886
+ /* "netCDF4/_netCDF4.pyx":3889
* if self.dtype == str: # VLEN string
* strdata = <char **>malloc(sizeof(char *))
* bytestr = _strencode(data) # <<<<<<<<<<<<<<
* strdata[0] = bytestr
* ierr = nc_put_vara(self._grpid, self._varid,
*/
- __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_data, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3886; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_data, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3889, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_v_bytestr = __pyx_t_8;
__pyx_t_8 = 0;
- /* "netCDF4/_netCDF4.pyx":3887
+ /* "netCDF4/_netCDF4.pyx":3890
* strdata = <char **>malloc(sizeof(char *))
* bytestr = _strencode(data)
* strdata[0] = bytestr # <<<<<<<<<<<<<<
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, strdata)
*/
- __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3887; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_11) && PyErr_Occurred())) __PYX_ERR(0, 3890, __pyx_L1_error)
(__pyx_v_strdata[0]) = __pyx_t_11;
- /* "netCDF4/_netCDF4.pyx":3888
+ /* "netCDF4/_netCDF4.pyx":3891
* bytestr = _strencode(data)
* strdata[0] = bytestr
* ierr = nc_put_vara(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -40594,7 +40246,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
__pyx_v_ierr = nc_put_vara(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_strdata);
- /* "netCDF4/_netCDF4.pyx":3890
+ /* "netCDF4/_netCDF4.pyx":3893
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, strdata)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -40604,7 +40256,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_2 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3891
+ /* "netCDF4/_netCDF4.pyx":3894
* startp, countp, strdata)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -40612,22 +40264,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
* else: # regular VLEN
*/
__pyx_t_11 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_8 = __Pyx_decode_c_string(__pyx_t_11, 0, strlen(__pyx_t_11), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_decode_c_string(__pyx_t_11, 0, strlen(__pyx_t_11), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3894, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3894, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3894, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3894, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3890
+ /* "netCDF4/_netCDF4.pyx":3893
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, strdata)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -40636,7 +40288,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3892
+ /* "netCDF4/_netCDF4.pyx":3895
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* free(strdata) # <<<<<<<<<<<<<<
@@ -40645,7 +40297,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
free(__pyx_v_strdata);
- /* "netCDF4/_netCDF4.pyx":3884
+ /* "netCDF4/_netCDF4.pyx":3887
* startp[n] = start[n]
* countp[n] = count[n]
* if self.dtype == str: # VLEN string # <<<<<<<<<<<<<<
@@ -40655,7 +40307,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
goto __pyx_L16;
}
- /* "netCDF4/_netCDF4.pyx":3894
+ /* "netCDF4/_netCDF4.pyx":3897
* free(strdata)
* else: # regular VLEN
* if data.dtype != self.dtype: # <<<<<<<<<<<<<<
@@ -40663,24 +40315,24 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
* data2 = data
*/
/*else*/ {
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3897, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_3 = PyObject_RichCompare(__pyx_t_8, __pyx_v_self->dtype, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_8, __pyx_v_self->dtype, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3897, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3894; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 3897, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3895
+ /* "netCDF4/_netCDF4.pyx":3898
* else: # regular VLEN
* if data.dtype != self.dtype:
* raise TypeError("wrong data type: should be %s, got %s" % (self.dtype,data.dtype)) # <<<<<<<<<<<<<<
* data2 = data
* vldata = <nc_vlen_t *>malloc(sizeof(nc_vlen_t))
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3898, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3898, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
@@ -40688,22 +40340,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_wrong_data_type_should_be_s_got, __pyx_t_8); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_wrong_data_type_should_be_s_got, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3898, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3898, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3898, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3895; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3898, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3894
+ /* "netCDF4/_netCDF4.pyx":3897
* free(strdata)
* else: # regular VLEN
* if data.dtype != self.dtype: # <<<<<<<<<<<<<<
@@ -40712,20 +40364,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3896
+ /* "netCDF4/_netCDF4.pyx":3899
* if data.dtype != self.dtype:
* raise TypeError("wrong data type: should be %s, got %s" % (self.dtype,data.dtype))
* data2 = data # <<<<<<<<<<<<<<
* vldata = <nc_vlen_t *>malloc(sizeof(nc_vlen_t))
* vldata[0].len = PyArray_SIZE(data2)
*/
- if (!(likely(((__pyx_v_data) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_data, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3896; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_v_data) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_data, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 3899, __pyx_L1_error)
__pyx_t_3 = __pyx_v_data;
__Pyx_INCREF(__pyx_t_3);
__pyx_v_data2 = ((PyArrayObject *)__pyx_t_3);
__pyx_t_3 = 0;
- /* "netCDF4/_netCDF4.pyx":3897
+ /* "netCDF4/_netCDF4.pyx":3900
* raise TypeError("wrong data type: should be %s, got %s" % (self.dtype,data.dtype))
* data2 = data
* vldata = <nc_vlen_t *>malloc(sizeof(nc_vlen_t)) # <<<<<<<<<<<<<<
@@ -40734,7 +40386,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
__pyx_v_vldata = ((nc_vlen_t *)malloc((sizeof(nc_vlen_t))));
- /* "netCDF4/_netCDF4.pyx":3898
+ /* "netCDF4/_netCDF4.pyx":3901
* data2 = data
* vldata = <nc_vlen_t *>malloc(sizeof(nc_vlen_t))
* vldata[0].len = PyArray_SIZE(data2) # <<<<<<<<<<<<<<
@@ -40743,7 +40395,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
(__pyx_v_vldata[0]).len = PyArray_SIZE(__pyx_v_data2);
- /* "netCDF4/_netCDF4.pyx":3899
+ /* "netCDF4/_netCDF4.pyx":3902
* vldata = <nc_vlen_t *>malloc(sizeof(nc_vlen_t))
* vldata[0].len = PyArray_SIZE(data2)
* vldata[0].p = data2.data # <<<<<<<<<<<<<<
@@ -40753,7 +40405,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_11 = __pyx_v_data2->data;
(__pyx_v_vldata[0]).p = __pyx_t_11;
- /* "netCDF4/_netCDF4.pyx":3900
+ /* "netCDF4/_netCDF4.pyx":3903
* vldata[0].len = PyArray_SIZE(data2)
* vldata[0].p = data2.data
* ierr = nc_put_vara(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -40762,7 +40414,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
__pyx_v_ierr = nc_put_vara(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_vldata);
- /* "netCDF4/_netCDF4.pyx":3902
+ /* "netCDF4/_netCDF4.pyx":3905
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, vldata)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -40772,7 +40424,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
__pyx_t_2 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_2) {
- /* "netCDF4/_netCDF4.pyx":3903
+ /* "netCDF4/_netCDF4.pyx":3906
* startp, countp, vldata)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -40780,22 +40432,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
* free(startp)
*/
__pyx_t_11 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_11, 0, strlen(__pyx_t_11), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_decode_c_string(__pyx_t_11, 0, strlen(__pyx_t_11), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3906, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3906, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3906, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3903; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3906, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3902
+ /* "netCDF4/_netCDF4.pyx":3905
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, vldata)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -40804,7 +40456,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
}
- /* "netCDF4/_netCDF4.pyx":3904
+ /* "netCDF4/_netCDF4.pyx":3907
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* free(vldata) # <<<<<<<<<<<<<<
@@ -40815,7 +40467,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
}
__pyx_L16:;
- /* "netCDF4/_netCDF4.pyx":3905
+ /* "netCDF4/_netCDF4.pyx":3908
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* free(vldata)
* free(startp) # <<<<<<<<<<<<<<
@@ -40824,7 +40476,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
free(__pyx_v_startp);
- /* "netCDF4/_netCDF4.pyx":3906
+ /* "netCDF4/_netCDF4.pyx":3909
* free(vldata)
* free(startp)
* free(countp) # <<<<<<<<<<<<<<
@@ -40833,7 +40485,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
*/
free(__pyx_v_countp);
- /* "netCDF4/_netCDF4.pyx":3833
+ /* "netCDF4/_netCDF4.pyx":3836
* return data
*
* def _assign_vlen(self, elem, data): # <<<<<<<<<<<<<<
@@ -40865,7 +40517,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_48_assign_vlen(struct __p
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":3908
+/* "netCDF4/_netCDF4.pyx":3911
* free(countp)
*
* def __setitem__(self, elem, data): # <<<<<<<<<<<<<<
@@ -40918,55 +40570,52 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
Py_ssize_t __pyx_t_13;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setitem__", 0);
__Pyx_INCREF(__pyx_v_elem);
__Pyx_INCREF(__pyx_v_data);
- /* "netCDF4/_netCDF4.pyx":3915
+ /* "netCDF4/_netCDF4.pyx":3918
* # to use.
*
* if self._isvlen: # if vlen, should be object array (don't try casting) # <<<<<<<<<<<<<<
* if self.dtype == str:
* # for string vars, if data is not an array
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3915; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3918, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3916
+ /* "netCDF4/_netCDF4.pyx":3919
*
* if self._isvlen: # if vlen, should be object array (don't try casting)
* if self.dtype == str: # <<<<<<<<<<<<<<
* # for string vars, if data is not an array
* # assume it is a python string and raise an error
*/
- __pyx_t_2 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3916; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3916; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3919, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3919, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3920
+ /* "netCDF4/_netCDF4.pyx":3923
* # assume it is a python string and raise an error
* # if it is an array, but not an object array.
* if not hasattr(data,'ndim'): # <<<<<<<<<<<<<<
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\
*/
- __pyx_t_1 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3920; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 3923, __pyx_L1_error)
__pyx_t_3 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3922
+ /* "netCDF4/_netCDF4.pyx":3925
* if not hasattr(data,'ndim'):
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\ # <<<<<<<<<<<<<<
* len(self.dimensions): elem = 0
* self._assign_vlen(elem, data)
*/
- __pyx_t_2 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_elem)), ((PyObject *)Py_TYPE(__pyx_builtin_Ellipsis)), Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3922; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3922; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_elem)), ((PyObject *)Py_TYPE(__pyx_builtin_Ellipsis)), Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3925, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3925, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_1) {
} else {
@@ -40974,19 +40623,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L7_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":3923
+ /* "netCDF4/_netCDF4.pyx":3926
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\
* len(self.dimensions): elem = 0 # <<<<<<<<<<<<<<
* self._assign_vlen(elem, data)
* return
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3923; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3926, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3923; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 3926, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3922
+ /* "netCDF4/_netCDF4.pyx":3925
* if not hasattr(data,'ndim'):
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\ # <<<<<<<<<<<<<<
@@ -40998,7 +40647,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_L7_bool_binop_done:;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3923
+ /* "netCDF4/_netCDF4.pyx":3926
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\
* len(self.dimensions): elem = 0 # <<<<<<<<<<<<<<
@@ -41008,7 +40657,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_int_0);
__Pyx_DECREF_SET(__pyx_v_elem, __pyx_int_0);
- /* "netCDF4/_netCDF4.pyx":3922
+ /* "netCDF4/_netCDF4.pyx":3925
* if not hasattr(data,'ndim'):
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\ # <<<<<<<<<<<<<<
@@ -41017,14 +40666,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3924
+ /* "netCDF4/_netCDF4.pyx":3927
* if type(elem) == type(Ellipsis) and not\
* len(self.dimensions): elem = 0
* self._assign_vlen(elem, data) # <<<<<<<<<<<<<<
* return
* elif data.dtype.kind in ['S', 'U']:
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_assign_vlen); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3924; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_assign_vlen); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3927, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
__pyx_t_4 = 0;
@@ -41038,7 +40687,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3924; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3927, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
@@ -41049,13 +40698,13 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_4, __pyx_v_data);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3924; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3927, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3925
+ /* "netCDF4/_netCDF4.pyx":3928
* len(self.dimensions): elem = 0
* self._assign_vlen(elem, data)
* return # <<<<<<<<<<<<<<
@@ -41065,7 +40714,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_r = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3920
+ /* "netCDF4/_netCDF4.pyx":3923
* # assume it is a python string and raise an error
* # if it is an array, but not an object array.
* if not hasattr(data,'ndim'): # <<<<<<<<<<<<<<
@@ -41074,41 +40723,41 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3926
+ /* "netCDF4/_netCDF4.pyx":3929
* self._assign_vlen(elem, data)
* return
* elif data.dtype.kind in ['S', 'U']: # <<<<<<<<<<<<<<
* if ma.isMA(data):
* msg='masked arrays cannot be assigned by VLEN str slices'
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3929, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3929, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_S, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_S, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3929, __pyx_L1_error)
if (!__pyx_t_1) {
} else {
__pyx_t_3 = __pyx_t_1;
goto __pyx_L9_bool_binop_done;
}
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_U, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3926; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_U, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3929, __pyx_L1_error)
__pyx_t_3 = __pyx_t_1;
__pyx_L9_bool_binop_done:;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3927
+ /* "netCDF4/_netCDF4.pyx":3930
* return
* elif data.dtype.kind in ['S', 'U']:
* if ma.isMA(data): # <<<<<<<<<<<<<<
* msg='masked arrays cannot be assigned by VLEN str slices'
* raise TypeError(msg)
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isMA); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isMA); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -41122,25 +40771,25 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_2) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_data);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3927; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3930, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3928
+ /* "netCDF4/_netCDF4.pyx":3931
* elif data.dtype.kind in ['S', 'U']:
* if ma.isMA(data):
* msg='masked arrays cannot be assigned by VLEN str slices' # <<<<<<<<<<<<<<
@@ -41150,26 +40799,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_kp_s_masked_arrays_cannot_be_assigned);
__pyx_v_msg = __pyx_kp_s_masked_arrays_cannot_be_assigned;
- /* "netCDF4/_netCDF4.pyx":3929
+ /* "netCDF4/_netCDF4.pyx":3932
* if ma.isMA(data):
* msg='masked arrays cannot be assigned by VLEN str slices'
* raise TypeError(msg) # <<<<<<<<<<<<<<
* data = data.astype(object)
* elif data.dtype.kind != 'O':
*/
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3929; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3932, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_msg);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3929; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3932, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3929; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3932, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3927
+ /* "netCDF4/_netCDF4.pyx":3930
* return
* elif data.dtype.kind in ['S', 'U']:
* if ma.isMA(data): # <<<<<<<<<<<<<<
@@ -41178,14 +40827,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3930
+ /* "netCDF4/_netCDF4.pyx":3933
* msg='masked arrays cannot be assigned by VLEN str slices'
* raise TypeError(msg)
* data = data.astype(object) # <<<<<<<<<<<<<<
* elif data.dtype.kind != 'O':
* msg = ('only numpy string, unicode or object arrays can '
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_astype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3930; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_astype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3933, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -41198,16 +40847,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_6) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_builtin_object); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3930; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_builtin_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3933, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3930; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3933, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_builtin_object);
__Pyx_GIVEREF(__pyx_builtin_object);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_builtin_object);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3930; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_2, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3933, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -41215,7 +40864,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3926
+ /* "netCDF4/_netCDF4.pyx":3929
* self._assign_vlen(elem, data)
* return
* elif data.dtype.kind in ['S', 'U']: # <<<<<<<<<<<<<<
@@ -41225,23 +40874,23 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L5;
}
- /* "netCDF4/_netCDF4.pyx":3931
+ /* "netCDF4/_netCDF4.pyx":3934
* raise TypeError(msg)
* data = data.astype(object)
* elif data.dtype.kind != 'O': # <<<<<<<<<<<<<<
* msg = ('only numpy string, unicode or object arrays can '
* 'be assigned to VLEN str var slices')
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3934, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3934, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_O, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_O, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3934, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3932
+ /* "netCDF4/_netCDF4.pyx":3935
* data = data.astype(object)
* elif data.dtype.kind != 'O':
* msg = ('only numpy string, unicode or object arrays can ' # <<<<<<<<<<<<<<
@@ -41251,26 +40900,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_kp_s_only_numpy_string_unicode_or_obj);
__pyx_v_msg = __pyx_kp_s_only_numpy_string_unicode_or_obj;
- /* "netCDF4/_netCDF4.pyx":3934
+ /* "netCDF4/_netCDF4.pyx":3937
* msg = ('only numpy string, unicode or object arrays can '
* 'be assigned to VLEN str var slices')
* raise TypeError(msg) # <<<<<<<<<<<<<<
* else:
* # for non-string vlen arrays, if data is not multi-dim, or
*/
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3934; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3937, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_msg);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3934; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3937, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3934; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3937, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3931
+ /* "netCDF4/_netCDF4.pyx":3934
* raise TypeError(msg)
* data = data.astype(object)
* elif data.dtype.kind != 'O': # <<<<<<<<<<<<<<
@@ -41280,7 +40929,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__pyx_L5:;
- /* "netCDF4/_netCDF4.pyx":3916
+ /* "netCDF4/_netCDF4.pyx":3919
*
* if self._isvlen: # if vlen, should be object array (don't try casting)
* if self.dtype == str: # <<<<<<<<<<<<<<
@@ -41290,7 +40939,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L4;
}
- /* "netCDF4/_netCDF4.pyx":3939
+ /* "netCDF4/_netCDF4.pyx":3942
* # not an object array, assume it represents a single element
* # of the vlen var.
* if not hasattr(data,'ndim') or data.dtype.kind != 'O': # <<<<<<<<<<<<<<
@@ -41298,33 +40947,33 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
* if type(elem) == type(Ellipsis) and not\
*/
/*else*/ {
- __pyx_t_3 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 3942, __pyx_L1_error)
__pyx_t_8 = ((!(__pyx_t_3 != 0)) != 0);
if (!__pyx_t_8) {
} else {
__pyx_t_1 = __pyx_t_8;
goto __pyx_L13_bool_binop_done;
}
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3942, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3942, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_O, Py_NE)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_n_s_O, Py_NE)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3942, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_1 = __pyx_t_8;
__pyx_L13_bool_binop_done:;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3941
+ /* "netCDF4/_netCDF4.pyx":3944
* if not hasattr(data,'ndim') or data.dtype.kind != 'O':
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\ # <<<<<<<<<<<<<<
* len(self.dimensions): elem = 0
* self._assign_vlen(elem, data)
*/
- __pyx_t_5 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_elem)), ((PyObject *)Py_TYPE(__pyx_builtin_Ellipsis)), Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_RichCompare(((PyObject *)Py_TYPE(__pyx_v_elem)), ((PyObject *)Py_TYPE(__pyx_builtin_Ellipsis)), Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3944, __pyx_L1_error)
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3944, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_8) {
} else {
@@ -41332,19 +40981,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L16_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":3942
+ /* "netCDF4/_netCDF4.pyx":3945
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\
* len(self.dimensions): elem = 0 # <<<<<<<<<<<<<<
* self._assign_vlen(elem, data)
* return
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3942; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3942; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_Length(__pyx_t_5); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 3945, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3941
+ /* "netCDF4/_netCDF4.pyx":3944
* if not hasattr(data,'ndim') or data.dtype.kind != 'O':
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\ # <<<<<<<<<<<<<<
@@ -41356,7 +41005,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_L16_bool_binop_done:;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":3942
+ /* "netCDF4/_netCDF4.pyx":3945
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\
* len(self.dimensions): elem = 0 # <<<<<<<<<<<<<<
@@ -41366,7 +41015,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_int_0);
__Pyx_DECREF_SET(__pyx_v_elem, __pyx_int_0);
- /* "netCDF4/_netCDF4.pyx":3941
+ /* "netCDF4/_netCDF4.pyx":3944
* if not hasattr(data,'ndim') or data.dtype.kind != 'O':
* # issue 458, allow Ellipsis to be used for scalar var
* if type(elem) == type(Ellipsis) and not\ # <<<<<<<<<<<<<<
@@ -41375,14 +41024,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3943
+ /* "netCDF4/_netCDF4.pyx":3946
* if type(elem) == type(Ellipsis) and not\
* len(self.dimensions): elem = 0
* self._assign_vlen(elem, data) # <<<<<<<<<<<<<<
* return
*
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_assign_vlen); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3943; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_assign_vlen); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_2 = NULL;
__pyx_t_4 = 0;
@@ -41396,7 +41045,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_6 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3943; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_2) {
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -41407,13 +41056,13 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_4, __pyx_v_data);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3943; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3944
+ /* "netCDF4/_netCDF4.pyx":3947
* len(self.dimensions): elem = 0
* self._assign_vlen(elem, data)
* return # <<<<<<<<<<<<<<
@@ -41423,7 +41072,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_r = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":3939
+ /* "netCDF4/_netCDF4.pyx":3942
* # not an object array, assume it represents a single element
* # of the vlen var.
* if not hasattr(data,'ndim') or data.dtype.kind != 'O': # <<<<<<<<<<<<<<
@@ -41434,7 +41083,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__pyx_L4:;
- /* "netCDF4/_netCDF4.pyx":3915
+ /* "netCDF4/_netCDF4.pyx":3918
* # to use.
*
* if self._isvlen: # if vlen, should be object array (don't try casting) # <<<<<<<<<<<<<<
@@ -41443,32 +41092,32 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3948
+ /* "netCDF4/_netCDF4.pyx":3951
* # A numpy array is needed. Convert if necessary.
* # assume it's a numpy or masked array if it has an 'ndim' attribute.
* if not hasattr(data,'ndim'): # <<<<<<<<<<<<<<
* # if auto scaling is to be done, don't cast to an integer yet.
* if self.scale and self.dtype.kind in 'iu' and \
*/
- __pyx_t_1 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3948; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_HasAttr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 3951, __pyx_L1_error)
__pyx_t_8 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3950
+ /* "netCDF4/_netCDF4.pyx":3953
* if not hasattr(data,'ndim'):
* # if auto scaling is to be done, don't cast to an integer yet.
* if self.scale and self.dtype.kind in 'iu' and \ # <<<<<<<<<<<<<<
* hasattr(self, 'scale_factor') or hasattr(self, 'add_offset'):
* data = numpy.array(data,numpy.float)
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->scale); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3950; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->scale); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3953, __pyx_L1_error)
if (!__pyx_t_1) {
goto __pyx_L21_next_or;
} else {
}
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3950; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3953, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_n_s_iu, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3950; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_n_s_iu, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 3953, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_3 = (__pyx_t_1 != 0);
if (!__pyx_t_3) {
@@ -41476,14 +41125,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
} else {
}
- /* "netCDF4/_netCDF4.pyx":3951
+ /* "netCDF4/_netCDF4.pyx":3954
* # if auto scaling is to be done, don't cast to an integer yet.
* if self.scale and self.dtype.kind in 'iu' and \
* hasattr(self, 'scale_factor') or hasattr(self, 'add_offset'): # <<<<<<<<<<<<<<
* data = numpy.array(data,numpy.float)
* else:
*/
- __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 3954, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_3 != 0);
if (!__pyx_t_1) {
} else {
@@ -41491,12 +41140,12 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L20_bool_binop_done;
}
__pyx_L21_next_or:;
- __pyx_t_1 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3951; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 3954, __pyx_L1_error)
__pyx_t_3 = (__pyx_t_1 != 0);
__pyx_t_8 = __pyx_t_3;
__pyx_L20_bool_binop_done:;
- /* "netCDF4/_netCDF4.pyx":3950
+ /* "netCDF4/_netCDF4.pyx":3953
* if not hasattr(data,'ndim'):
* # if auto scaling is to be done, don't cast to an integer yet.
* if self.scale and self.dtype.kind in 'iu' and \ # <<<<<<<<<<<<<<
@@ -41505,21 +41154,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3952
+ /* "netCDF4/_netCDF4.pyx":3955
* if self.scale and self.dtype.kind in 'iu' and \
* hasattr(self, 'scale_factor') or hasattr(self, 'add_offset'):
* data = numpy.array(data,numpy.float) # <<<<<<<<<<<<<<
* else:
* data = numpy.array(data,self.dtype)
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_float); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = NULL;
@@ -41534,7 +41183,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_9 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -41545,14 +41194,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_4, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3952; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3950
+ /* "netCDF4/_netCDF4.pyx":3953
* if not hasattr(data,'ndim'):
* # if auto scaling is to be done, don't cast to an integer yet.
* if self.scale and self.dtype.kind in 'iu' and \ # <<<<<<<<<<<<<<
@@ -41562,7 +41211,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L19;
}
- /* "netCDF4/_netCDF4.pyx":3954
+ /* "netCDF4/_netCDF4.pyx":3957
* data = numpy.array(data,numpy.float)
* else:
* data = numpy.array(data,self.dtype) # <<<<<<<<<<<<<<
@@ -41570,9 +41219,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
* # for Enum variable, make sure data is valid.
*/
/*else*/ {
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3957, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_array); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3957, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -41587,7 +41236,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_2 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3957, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_6); __pyx_t_6 = NULL;
@@ -41598,7 +41247,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_4, __pyx_v_self->dtype);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3957, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -41607,7 +41256,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__pyx_L19:;
- /* "netCDF4/_netCDF4.pyx":3948
+ /* "netCDF4/_netCDF4.pyx":3951
* # A numpy array is needed. Convert if necessary.
* # assume it's a numpy or masked array if it has an 'ndim' attribute.
* if not hasattr(data,'ndim'): # <<<<<<<<<<<<<<
@@ -41616,33 +41265,33 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3957
+ /* "netCDF4/_netCDF4.pyx":3960
*
* # for Enum variable, make sure data is valid.
* if self._isenum: # <<<<<<<<<<<<<<
* test = numpy.zeros(data.shape,numpy.bool)
* for val in self.datatype.enum_dict.values():
*/
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3957; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3960, __pyx_L1_error)
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":3958
+ /* "netCDF4/_netCDF4.pyx":3961
* # for Enum variable, make sure data is valid.
* if self._isenum:
* test = numpy.zeros(data.shape,numpy.bool) # <<<<<<<<<<<<<<
* for val in self.datatype.enum_dict.values():
* test += data == val
*/
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_bool); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_bool); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -41657,7 +41306,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL;
@@ -41668,26 +41317,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_4, __pyx_t_7);
__pyx_t_9 = 0;
__pyx_t_7 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3958; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_test = __pyx_t_5;
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3959
+ /* "netCDF4/_netCDF4.pyx":3962
* if self._isenum:
* test = numpy.zeros(data.shape,numpy.bool)
* for val in self.datatype.enum_dict.values(): # <<<<<<<<<<<<<<
* test += data == val
* if not numpy.all(test):
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_datatype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_datatype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_enum_dict); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_enum_dict); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_values); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = NULL;
@@ -41701,10 +41350,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (__pyx_t_10) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_10); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3962, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3962, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -41712,9 +41361,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_2 = __pyx_t_5; __Pyx_INCREF(__pyx_t_2); __pyx_t_4 = 0;
__pyx_t_11 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3962, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
for (;;) {
@@ -41722,17 +41371,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 3962, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_4); __Pyx_INCREF(__pyx_t_5); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 3962, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
}
@@ -41742,7 +41391,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3959; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 3962, __pyx_L1_error)
}
break;
}
@@ -41751,21 +41400,21 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_XDECREF_SET(__pyx_v_val, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":3960
+ /* "netCDF4/_netCDF4.pyx":3963
* test = numpy.zeros(data.shape,numpy.bool)
* for val in self.datatype.enum_dict.values():
* test += data == val # <<<<<<<<<<<<<<
* if not numpy.all(test):
* msg="trying to assign illegal value to Enum variable"
*/
- __pyx_t_5 = PyObject_RichCompare(__pyx_v_data, __pyx_v_val, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_10 = PyNumber_InPlaceAdd(__pyx_v_test, __pyx_t_5); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_RichCompare(__pyx_v_data, __pyx_v_val, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3963, __pyx_L1_error)
+ __pyx_t_10 = PyNumber_InPlaceAdd(__pyx_v_test, __pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF_SET(__pyx_v_test, __pyx_t_10);
__pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":3959
+ /* "netCDF4/_netCDF4.pyx":3962
* if self._isenum:
* test = numpy.zeros(data.shape,numpy.bool)
* for val in self.datatype.enum_dict.values(): # <<<<<<<<<<<<<<
@@ -41775,16 +41424,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3961
+ /* "netCDF4/_netCDF4.pyx":3964
* for val in self.datatype.enum_dict.values():
* test += data == val
* if not numpy.all(test): # <<<<<<<<<<<<<<
* msg="trying to assign illegal value to Enum variable"
* raise ValueError(msg)
*/
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3961; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_all); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3961; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_all); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = NULL;
@@ -41798,26 +41447,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_10) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_test); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3961; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_test); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3961; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_10); __pyx_t_10 = NULL;
__Pyx_INCREF(__pyx_v_test);
__Pyx_GIVEREF(__pyx_v_test);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_test);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3961; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3961; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 3964, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_3 = ((!__pyx_t_8) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3962
+ /* "netCDF4/_netCDF4.pyx":3965
* test += data == val
* if not numpy.all(test):
* msg="trying to assign illegal value to Enum variable" # <<<<<<<<<<<<<<
@@ -41827,26 +41476,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_kp_s_trying_to_assign_illegal_value_t);
__pyx_v_msg = __pyx_kp_s_trying_to_assign_illegal_value_t;
- /* "netCDF4/_netCDF4.pyx":3963
+ /* "netCDF4/_netCDF4.pyx":3966
* if not numpy.all(test):
* msg="trying to assign illegal value to Enum variable"
* raise ValueError(msg) # <<<<<<<<<<<<<<
*
* start, count, stride, put_ind =\
*/
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3963; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3966, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3963; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3966, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3963; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3966, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":3961
+ /* "netCDF4/_netCDF4.pyx":3964
* for val in self.datatype.enum_dict.values():
* test += data == val
* if not numpy.all(test): # <<<<<<<<<<<<<<
@@ -41855,7 +41504,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3957
+ /* "netCDF4/_netCDF4.pyx":3960
*
* # for Enum variable, make sure data is valid.
* if self._isenum: # <<<<<<<<<<<<<<
@@ -41864,20 +41513,20 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3966
+ /* "netCDF4/_netCDF4.pyx":3969
*
* start, count, stride, put_ind =\
* _StartCountStride(elem,self.shape,self.dimensions,self._grp,datashape=data.shape,put=True) # <<<<<<<<<<<<<<
* datashape = _out_array_shape(count)
*
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_StartCountStride); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_StartCountStride); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_10 = PyTuple_New(4); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_v_elem);
__Pyx_GIVEREF(__pyx_v_elem);
@@ -41891,14 +41540,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
PyTuple_SET_ITEM(__pyx_t_10, 3, __pyx_v_self->_grp);
__pyx_t_2 = 0;
__pyx_t_7 = 0;
- __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_datashape, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_datashape, __pyx_t_2) < 0) __PYX_ERR(0, 3969, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_put, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3966; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_put, Py_True) < 0) __PYX_ERR(0, 3969, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
@@ -41913,7 +41562,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
if (unlikely(size != 4)) {
if (size > 4) __Pyx_RaiseTooManyValuesError(4);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3965; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3968, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -41936,7 +41585,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
Py_ssize_t i;
PyObject** temps[4] = {&__pyx_t_7,&__pyx_t_10,&__pyx_t_5,&__pyx_t_9};
for (i=0; i < 4; i++) {
- PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3965; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 3968, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
@@ -41946,7 +41595,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
} else {
Py_ssize_t index = -1;
PyObject** temps[4] = {&__pyx_t_7,&__pyx_t_10,&__pyx_t_5,&__pyx_t_9};
- __pyx_t_6 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3965; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3968, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_12 = Py_TYPE(__pyx_t_6)->tp_iternext;
@@ -41955,7 +41604,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_6), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3965; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_6), 4) < 0) __PYX_ERR(0, 3968, __pyx_L1_error)
__pyx_t_12 = NULL;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L29_unpacking_done;
@@ -41963,11 +41612,11 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_12 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3965; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 3968, __pyx_L1_error)
__pyx_L29_unpacking_done:;
}
- /* "netCDF4/_netCDF4.pyx":3965
+ /* "netCDF4/_netCDF4.pyx":3968
* raise ValueError(msg)
*
* start, count, stride, put_ind =\ # <<<<<<<<<<<<<<
@@ -41983,14 +41632,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_v_put_ind = __pyx_t_9;
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3967
+ /* "netCDF4/_netCDF4.pyx":3970
* start, count, stride, put_ind =\
* _StartCountStride(elem,self.shape,self.dimensions,self._grp,datashape=data.shape,put=True)
* datashape = _out_array_shape(count) # <<<<<<<<<<<<<<
*
* # if a numpy scalar, create an array of the right size
*/
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_out_array_shape); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3967; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_out_array_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3970, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_9))) {
@@ -42003,16 +41652,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_5) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_count); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3967; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3970, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3967; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3970, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_count);
__Pyx_GIVEREF(__pyx_v_count);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_count);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3967; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3970, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
@@ -42020,31 +41669,31 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_v_datashape = __pyx_t_2;
__pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":3971
+ /* "netCDF4/_netCDF4.pyx":3974
* # if a numpy scalar, create an array of the right size
* # and fill with scalar values.
* if data.shape == (): # <<<<<<<<<<<<<<
* data = numpy.tile(data,datashape)
* # reshape data array by adding extra singleton dimensions
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3974, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_9 = PyObject_RichCompare(__pyx_t_2, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_RichCompare(__pyx_t_2, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3974, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3974, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3972
+ /* "netCDF4/_netCDF4.pyx":3975
* # and fill with scalar values.
* if data.shape == ():
* data = numpy.tile(data,datashape) # <<<<<<<<<<<<<<
* # reshape data array by adding extra singleton dimensions
* # if needed to conform with start,count,stride.
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3972; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3975, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tile); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3972; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_tile); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3975, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -42059,7 +41708,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3972; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3975, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (__pyx_t_2) {
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -42070,14 +41719,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_datashape);
__Pyx_GIVEREF(__pyx_v_datashape);
PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_v_datashape);
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3972; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3975, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_9);
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3971
+ /* "netCDF4/_netCDF4.pyx":3974
* # if a numpy scalar, create an array of the right size
* # and fill with scalar values.
* if data.shape == (): # <<<<<<<<<<<<<<
@@ -42086,29 +41735,29 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3975
+ /* "netCDF4/_netCDF4.pyx":3978
* # reshape data array by adding extra singleton dimensions
* # if needed to conform with start,count,stride.
* if len(data.shape) != len(datashape): # <<<<<<<<<<<<<<
* # create a view so shape in caller is not modified (issue 90)
* data = data.view()
*/
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_shape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3978, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_4 = PyObject_Length(__pyx_t_9); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_Length(__pyx_t_9); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 3978, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_13 = PyObject_Length(__pyx_v_datashape); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = PyObject_Length(__pyx_v_datashape); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 3978, __pyx_L1_error)
__pyx_t_3 = ((__pyx_t_4 != __pyx_t_13) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3977
+ /* "netCDF4/_netCDF4.pyx":3980
* if len(data.shape) != len(datashape):
* # create a view so shape in caller is not modified (issue 90)
* data = data.view() # <<<<<<<<<<<<<<
* data.shape = tuple(datashape)
*
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_view); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_view); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3980, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_10))) {
@@ -42121,29 +41770,29 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (__pyx_t_5) {
- __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_5); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3980, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3980, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_9);
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3978
+ /* "netCDF4/_netCDF4.pyx":3981
* # create a view so shape in caller is not modified (issue 90)
* data = data.view()
* data.shape = tuple(datashape) # <<<<<<<<<<<<<<
*
* # Reshape these arrays so we can iterate over them.
*/
- __pyx_t_9 = PySequence_Tuple(__pyx_v_datashape); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3978; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PySequence_Tuple(__pyx_v_datashape); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3981, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_data, __pyx_n_s_shape, __pyx_t_9) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3978; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_data, __pyx_n_s_shape, __pyx_t_9) < 0) __PYX_ERR(0, 3981, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3975
+ /* "netCDF4/_netCDF4.pyx":3978
* # reshape data array by adding extra singleton dimensions
* # if needed to conform with start,count,stride.
* if len(data.shape) != len(datashape): # <<<<<<<<<<<<<<
@@ -42152,28 +41801,28 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3981
+ /* "netCDF4/_netCDF4.pyx":3984
*
* # Reshape these arrays so we can iterate over them.
* start = start.reshape((-1, self.ndim or 1)) # <<<<<<<<<<<<<<
* count = count.reshape((-1, self.ndim or 1))
* stride = stride.reshape((-1, self.ndim or 1))
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_start, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_start, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3984, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__Pyx_INCREF(__pyx_v_self->ndim);
__pyx_t_5 = __pyx_v_self->ndim;
goto __pyx_L32_bool_binop_done;
}
- __pyx_t_2 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_5 = __pyx_t_2;
__pyx_t_2 = 0;
__pyx_L32_bool_binop_done:;
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -42192,17 +41841,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_5) {
- __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3984, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -42210,28 +41859,28 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_DECREF_SET(__pyx_v_start, __pyx_t_9);
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3982
+ /* "netCDF4/_netCDF4.pyx":3985
* # Reshape these arrays so we can iterate over them.
* start = start.reshape((-1, self.ndim or 1))
* count = count.reshape((-1, self.ndim or 1)) # <<<<<<<<<<<<<<
* stride = stride.reshape((-1, self.ndim or 1))
* put_ind = put_ind.reshape((-1, self.ndim or 1))
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_count, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_count, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3985, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3985, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__Pyx_INCREF(__pyx_v_self->ndim);
__pyx_t_7 = __pyx_v_self->ndim;
goto __pyx_L34_bool_binop_done;
}
- __pyx_t_2 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3985, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_7 = __pyx_t_2;
__pyx_t_2 = 0;
__pyx_L34_bool_binop_done:;
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3985, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -42250,17 +41899,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_7) {
- __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3985, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3985, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3985, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
@@ -42268,28 +41917,28 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_DECREF_SET(__pyx_v_count, __pyx_t_9);
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3983
+ /* "netCDF4/_netCDF4.pyx":3986
* start = start.reshape((-1, self.ndim or 1))
* count = count.reshape((-1, self.ndim or 1))
* stride = stride.reshape((-1, self.ndim or 1)) # <<<<<<<<<<<<<<
* put_ind = put_ind.reshape((-1, self.ndim or 1))
*
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_stride, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_stride, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3986, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3986, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__Pyx_INCREF(__pyx_v_self->ndim);
__pyx_t_5 = __pyx_v_self->ndim;
goto __pyx_L36_bool_binop_done;
}
- __pyx_t_2 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3986, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_5 = __pyx_t_2;
__pyx_t_2 = 0;
__pyx_L36_bool_binop_done:;
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3986, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -42308,17 +41957,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_5) {
- __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3986, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3986, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3986, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -42326,28 +41975,28 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_DECREF_SET(__pyx_v_stride, __pyx_t_9);
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3984
+ /* "netCDF4/_netCDF4.pyx":3987
* count = count.reshape((-1, self.ndim or 1))
* stride = stride.reshape((-1, self.ndim or 1))
* put_ind = put_ind.reshape((-1, self.ndim or 1)) # <<<<<<<<<<<<<<
*
* # quantize data if least_significant_digit attribute
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_reshape); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->ndim); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3987, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__Pyx_INCREF(__pyx_v_self->ndim);
__pyx_t_7 = __pyx_v_self->ndim;
goto __pyx_L38_bool_binop_done;
}
- __pyx_t_2 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_7 = __pyx_t_2;
__pyx_t_2 = 0;
__pyx_L38_bool_binop_done:;
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -42366,17 +42015,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_7) {
- __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3987, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
@@ -42384,26 +42033,26 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_DECREF_SET(__pyx_v_put_ind, __pyx_t_9);
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3988
+ /* "netCDF4/_netCDF4.pyx":3991
* # quantize data if least_significant_digit attribute
* # exists (improves compression).
* if self._has_lsd: # <<<<<<<<<<<<<<
* data = _quantize(data,self.least_significant_digit)
* # if auto_scale mode set to True, (through
*/
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_has_lsd); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3988; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_has_lsd); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 3991, __pyx_L1_error)
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":3989
+ /* "netCDF4/_netCDF4.pyx":3992
* # exists (improves compression).
* if self._has_lsd:
* data = _quantize(data,self.least_significant_digit) # <<<<<<<<<<<<<<
* # if auto_scale mode set to True, (through
* # a call to set_auto_scale or set_auto_maskandscale),
*/
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_quantize); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_quantize); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3992, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_least_significant_digit); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_least_significant_digit); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3992, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_2 = NULL;
__pyx_t_13 = 0;
@@ -42417,7 +42066,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_13 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3992, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_2) {
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -42428,14 +42077,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_13, __pyx_t_5);
__pyx_t_5 = 0;
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3992, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_9);
__pyx_t_9 = 0;
- /* "netCDF4/_netCDF4.pyx":3988
+ /* "netCDF4/_netCDF4.pyx":3991
* # quantize data if least_significant_digit attribute
* # exists (improves compression).
* if self._has_lsd: # <<<<<<<<<<<<<<
@@ -42444,60 +42093,60 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3998
+ /* "netCDF4/_netCDF4.pyx":4001
* # missing_value/_Fill_Value.
* # ignore if not a primitive or enum data type (not compound or vlen).
* if self.mask and (self._isprimitive or self._isenum): # <<<<<<<<<<<<<<
* # use missing_value as fill value.
* # if no missing value set, use _FillValue.
*/
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->mask); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3998; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->mask); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 4001, __pyx_L1_error)
if (__pyx_t_8) {
} else {
__pyx_t_3 = __pyx_t_8;
goto __pyx_L42_bool_binop_done;
}
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3998; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 4001, __pyx_L1_error)
if (!__pyx_t_8) {
} else {
__pyx_t_3 = __pyx_t_8;
goto __pyx_L42_bool_binop_done;
}
- __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3998; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 4001, __pyx_L1_error)
__pyx_t_3 = __pyx_t_8;
__pyx_L42_bool_binop_done:;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4001
+ /* "netCDF4/_netCDF4.pyx":4004
* # use missing_value as fill value.
* # if no missing value set, use _FillValue.
* if hasattr(self, 'scale_factor') or hasattr(self, 'add_offset'): # <<<<<<<<<<<<<<
* # if not masked, create a masked array.
* if not ma.isMA(data): data = self._toma(data)
*/
- __pyx_t_8 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4001; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 4004, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_8 != 0);
if (!__pyx_t_1) {
} else {
__pyx_t_3 = __pyx_t_1;
goto __pyx_L46_bool_binop_done;
}
- __pyx_t_1 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4001; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 4004, __pyx_L1_error)
__pyx_t_8 = (__pyx_t_1 != 0);
__pyx_t_3 = __pyx_t_8;
__pyx_L46_bool_binop_done:;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4003
+ /* "netCDF4/_netCDF4.pyx":4006
* if hasattr(self, 'scale_factor') or hasattr(self, 'add_offset'):
* # if not masked, create a masked array.
* if not ma.isMA(data): data = self._toma(data) # <<<<<<<<<<<<<<
* if self.scale and self._isprimitive:
* # pack non-masked values using scale_factor and add_offset
*/
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_isMA); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_isMA); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = NULL;
@@ -42511,25 +42160,25 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_10) {
- __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_10); __pyx_t_10 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_data);
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_8 = ((!__pyx_t_3) != 0);
if (__pyx_t_8) {
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_toma); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_toma); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -42542,16 +42191,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_5) {
- __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
} else {
- __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_data);
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4006, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
@@ -42560,7 +42209,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_9 = 0;
}
- /* "netCDF4/_netCDF4.pyx":4001
+ /* "netCDF4/_netCDF4.pyx":4004
* # use missing_value as fill value.
* # if no missing value set, use _FillValue.
* if hasattr(self, 'scale_factor') or hasattr(self, 'add_offset'): # <<<<<<<<<<<<<<
@@ -42569,7 +42218,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":3998
+ /* "netCDF4/_netCDF4.pyx":4001
* # missing_value/_Fill_Value.
* # ignore if not a primitive or enum data type (not compound or vlen).
* if self.mask and (self._isprimitive or self._isenum): # <<<<<<<<<<<<<<
@@ -42578,81 +42227,81 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":4004
+ /* "netCDF4/_netCDF4.pyx":4007
* # if not masked, create a masked array.
* if not ma.isMA(data): data = self._toma(data)
* if self.scale and self._isprimitive: # <<<<<<<<<<<<<<
* # pack non-masked values using scale_factor and add_offset
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset'):
*/
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->scale); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->scale); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4007, __pyx_L1_error)
if (__pyx_t_3) {
} else {
__pyx_t_8 = __pyx_t_3;
goto __pyx_L50_bool_binop_done;
}
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4007, __pyx_L1_error)
__pyx_t_8 = __pyx_t_3;
__pyx_L50_bool_binop_done:;
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":4006
+ /* "netCDF4/_netCDF4.pyx":4009
* if self.scale and self._isprimitive:
* # pack non-masked values using scale_factor and add_offset
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset'): # <<<<<<<<<<<<<<
* data = (data - self.add_offset)/self.scale_factor
* if self.dtype.kind in 'iu': data = numpy.around(data)
*/
- __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4006; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 4009, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
} else {
__pyx_t_8 = __pyx_t_1;
goto __pyx_L53_bool_binop_done;
}
- __pyx_t_1 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4006; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 4009, __pyx_L1_error)
__pyx_t_3 = (__pyx_t_1 != 0);
__pyx_t_8 = __pyx_t_3;
__pyx_L53_bool_binop_done:;
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":4007
+ /* "netCDF4/_netCDF4.pyx":4010
* # pack non-masked values using scale_factor and add_offset
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset'):
* data = (data - self.add_offset)/self.scale_factor # <<<<<<<<<<<<<<
* if self.dtype.kind in 'iu': data = numpy.around(data)
* elif hasattr(self, 'scale_factor'):
*/
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4010, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_7 = PyNumber_Subtract(__pyx_v_data, __pyx_t_9); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyNumber_Subtract(__pyx_v_data, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4010, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4010, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyNumber_Divide(__pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4010, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_10);
__pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":4008
+ /* "netCDF4/_netCDF4.pyx":4011
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset'):
* data = (data - self.add_offset)/self.scale_factor
* if self.dtype.kind in 'iu': data = numpy.around(data) # <<<<<<<<<<<<<<
* elif hasattr(self, 'scale_factor'):
* data = data/self.scale_factor
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4011, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_t_10, __pyx_n_s_iu, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_t_10, __pyx_n_s_iu, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 4011, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_3 = (__pyx_t_8 != 0);
if (__pyx_t_3) {
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4011, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_around); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_around); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4011, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_9 = NULL;
@@ -42666,16 +42315,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_9) {
- __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_data); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4011, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4011, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_9); __pyx_t_9 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_data);
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4011, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
@@ -42684,7 +42333,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_10 = 0;
}
- /* "netCDF4/_netCDF4.pyx":4006
+ /* "netCDF4/_netCDF4.pyx":4009
* if self.scale and self._isprimitive:
* # pack non-masked values using scale_factor and add_offset
* if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset'): # <<<<<<<<<<<<<<
@@ -42694,48 +42343,48 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L52;
}
- /* "netCDF4/_netCDF4.pyx":4009
+ /* "netCDF4/_netCDF4.pyx":4012
* data = (data - self.add_offset)/self.scale_factor
* if self.dtype.kind in 'iu': data = numpy.around(data)
* elif hasattr(self, 'scale_factor'): # <<<<<<<<<<<<<<
* data = data/self.scale_factor
* if self.dtype.kind in 'iu': data = numpy.around(data)
*/
- __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4009; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 4012, __pyx_L1_error)
__pyx_t_8 = (__pyx_t_3 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":4010
+ /* "netCDF4/_netCDF4.pyx":4013
* if self.dtype.kind in 'iu': data = numpy.around(data)
* elif hasattr(self, 'scale_factor'):
* data = data/self.scale_factor # <<<<<<<<<<<<<<
* if self.dtype.kind in 'iu': data = numpy.around(data)
* elif hasattr(self, 'add_offset'):
*/
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4010; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_scale_factor); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4013, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_7 = __Pyx_PyNumber_Divide(__pyx_v_data, __pyx_t_10); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4010; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyNumber_Divide(__pyx_v_data, __pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4013, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_7);
__pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":4011
+ /* "netCDF4/_netCDF4.pyx":4014
* elif hasattr(self, 'scale_factor'):
* data = data/self.scale_factor
* if self.dtype.kind in 'iu': data = numpy.around(data) # <<<<<<<<<<<<<<
* elif hasattr(self, 'add_offset'):
* data = data - self.add_offset
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4014, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_t_7, __pyx_n_s_iu, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_t_7, __pyx_n_s_iu, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 4014, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_3 = (__pyx_t_8 != 0);
if (__pyx_t_3) {
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4014, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_around); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_around); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4014, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = NULL;
@@ -42749,16 +42398,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_10) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_data); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_data); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4014, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4014, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_10); __pyx_t_10 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_data);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4011; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4014, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
@@ -42767,7 +42416,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_7 = 0;
}
- /* "netCDF4/_netCDF4.pyx":4009
+ /* "netCDF4/_netCDF4.pyx":4012
* data = (data - self.add_offset)/self.scale_factor
* if self.dtype.kind in 'iu': data = numpy.around(data)
* elif hasattr(self, 'scale_factor'): # <<<<<<<<<<<<<<
@@ -42777,48 +42426,48 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L52;
}
- /* "netCDF4/_netCDF4.pyx":4012
+ /* "netCDF4/_netCDF4.pyx":4015
* data = data/self.scale_factor
* if self.dtype.kind in 'iu': data = numpy.around(data)
* elif hasattr(self, 'add_offset'): # <<<<<<<<<<<<<<
* data = data - self.add_offset
* if self.dtype.kind in 'iu': data = numpy.around(data)
*/
- __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4012; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 4015, __pyx_L1_error)
__pyx_t_8 = (__pyx_t_3 != 0);
if (__pyx_t_8) {
- /* "netCDF4/_netCDF4.pyx":4013
+ /* "netCDF4/_netCDF4.pyx":4016
* if self.dtype.kind in 'iu': data = numpy.around(data)
* elif hasattr(self, 'add_offset'):
* data = data - self.add_offset # <<<<<<<<<<<<<<
* if self.dtype.kind in 'iu': data = numpy.around(data)
* if ma.isMA(data):
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4013; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_add_offset); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4016, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = PyNumber_Subtract(__pyx_v_data, __pyx_t_7); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4013; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyNumber_Subtract(__pyx_v_data, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4016, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":4014
+ /* "netCDF4/_netCDF4.pyx":4017
* elif hasattr(self, 'add_offset'):
* data = data - self.add_offset
* if self.dtype.kind in 'iu': data = numpy.around(data) # <<<<<<<<<<<<<<
* if ma.isMA(data):
* # if underlying data in masked regions of masked array
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_kind); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_n_s_iu, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_n_s_iu, Py_EQ)); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 4017, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_3 = (__pyx_t_8 != 0);
if (__pyx_t_3) {
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_around); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_around); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = NULL;
@@ -42832,16 +42481,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_7) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_data); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_data);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4014; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
@@ -42850,7 +42499,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_5 = 0;
}
- /* "netCDF4/_netCDF4.pyx":4012
+ /* "netCDF4/_netCDF4.pyx":4015
* data = data/self.scale_factor
* if self.dtype.kind in 'iu': data = numpy.around(data)
* elif hasattr(self, 'add_offset'): # <<<<<<<<<<<<<<
@@ -42860,16 +42509,16 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__pyx_L52:;
- /* "netCDF4/_netCDF4.pyx":4015
+ /* "netCDF4/_netCDF4.pyx":4018
* data = data - self.add_offset
* if self.dtype.kind in 'iu': data = numpy.around(data)
* if ma.isMA(data): # <<<<<<<<<<<<<<
* # if underlying data in masked regions of masked array
* # corresponds to missing values, don't fill masked array -
*/
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4015; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4018, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_isMA); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4015; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_isMA); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4018, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_9 = NULL;
@@ -42883,32 +42532,32 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_9) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_data); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4015; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4018, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4015; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4018, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9); __pyx_t_9 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_data);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4015; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4018, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4015; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4018, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4019
+ /* "netCDF4/_netCDF4.pyx":4022
* # corresponds to missing values, don't fill masked array -
* # just use underlying data instead
* if hasattr(self, 'missing_value') and \ # <<<<<<<<<<<<<<
* numpy.all(numpy.in1d(data.data[data.mask],self.missing_value)):
* data = data.data
*/
- __pyx_t_8 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4019; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 4022, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_8 != 0);
if (__pyx_t_1) {
} else {
@@ -42916,32 +42565,32 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L60_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":4020
+ /* "netCDF4/_netCDF4.pyx":4023
* # just use underlying data instead
* if hasattr(self, 'missing_value') and \
* numpy.all(numpy.in1d(data.data[data.mask],self.missing_value)): # <<<<<<<<<<<<<<
* data = data.data
* else:
*/
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_all); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_all); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_in1d); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_n_s_in1d); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_data); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_data); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_mask); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_mask); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_14 = PyObject_GetItem(__pyx_t_9, __pyx_t_6); if (unlikely(__pyx_t_14 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_14 = PyObject_GetItem(__pyx_t_9, __pyx_t_6); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_9 = NULL;
__pyx_t_13 = 0;
@@ -42955,7 +42604,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_13 = 1;
}
}
- __pyx_t_15 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
if (__pyx_t_9) {
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_9); __pyx_t_9 = NULL;
@@ -42966,7 +42615,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_13, __pyx_t_6);
__pyx_t_14 = 0;
__pyx_t_6 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_15, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_15, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -42981,27 +42630,27 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_2) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_10);
__pyx_t_10 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_15, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_15, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 4023, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_3 = __pyx_t_1;
__pyx_L60_bool_binop_done:;
- /* "netCDF4/_netCDF4.pyx":4019
+ /* "netCDF4/_netCDF4.pyx":4022
* # corresponds to missing values, don't fill masked array -
* # just use underlying data instead
* if hasattr(self, 'missing_value') and \ # <<<<<<<<<<<<<<
@@ -43010,19 +42659,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4021
+ /* "netCDF4/_netCDF4.pyx":4024
* if hasattr(self, 'missing_value') and \
* numpy.all(numpy.in1d(data.data[data.mask],self.missing_value)):
* data = data.data # <<<<<<<<<<<<<<
* else:
* if hasattr(self, 'missing_value'):
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_data); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4021; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4024, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":4019
+ /* "netCDF4/_netCDF4.pyx":4022
* # corresponds to missing values, don't fill masked array -
* # just use underlying data instead
* if hasattr(self, 'missing_value') and \ # <<<<<<<<<<<<<<
@@ -43032,7 +42681,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L59;
}
- /* "netCDF4/_netCDF4.pyx":4023
+ /* "netCDF4/_netCDF4.pyx":4026
* data = data.data
* else:
* if hasattr(self, 'missing_value'): # <<<<<<<<<<<<<<
@@ -43040,23 +42689,23 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
* # if missing value is a vector, raise an exception
*/
/*else*/ {
- __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(__pyx_t_3 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(0, 4026, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":4027
+ /* "netCDF4/_netCDF4.pyx":4030
* # if missing value is a vector, raise an exception
* # since we then don't know how to fill in masked values.
* if numpy.array(self.missing_value).shape == (): # <<<<<<<<<<<<<<
* fillval = self.missing_value
* else:
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_array); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_10 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_15))) {
@@ -43069,43 +42718,43 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_10) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_7); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_10); __pyx_t_10 = NULL;
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_7);
__pyx_t_7 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_shape); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_shape); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyObject_RichCompare(__pyx_t_15, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_RichCompare(__pyx_t_15, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 4030, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":4028
+ /* "netCDF4/_netCDF4.pyx":4031
* # since we then don't know how to fill in masked values.
* if numpy.array(self.missing_value).shape == ():
* fillval = self.missing_value # <<<<<<<<<<<<<<
* else:
* msg="cannot assign fill_value for masked array when missing_value attribute is not a scalar"
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4028; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_missing_value); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4031, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_v_fillval = __pyx_t_5;
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":4027
+ /* "netCDF4/_netCDF4.pyx":4030
* # if missing value is a vector, raise an exception
* # since we then don't know how to fill in masked values.
* if numpy.array(self.missing_value).shape == (): # <<<<<<<<<<<<<<
@@ -43115,7 +42764,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L63;
}
- /* "netCDF4/_netCDF4.pyx":4030
+ /* "netCDF4/_netCDF4.pyx":4033
* fillval = self.missing_value
* else:
* msg="cannot assign fill_value for masked array when missing_value attribute is not a scalar" # <<<<<<<<<<<<<<
@@ -43126,37 +42775,37 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_kp_s_cannot_assign_fill_value_for_mas);
__pyx_v_msg = __pyx_kp_s_cannot_assign_fill_value_for_mas;
- /* "netCDF4/_netCDF4.pyx":4031
+ /* "netCDF4/_netCDF4.pyx":4034
* else:
* msg="cannot assign fill_value for masked array when missing_value attribute is not a scalar"
* raise RuntimeError(msg) # <<<<<<<<<<<<<<
* if numpy.array(fillval).shape != ():
* fillval = fillval[0]
*/
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4034, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_msg);
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4034, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_15, 0, 0, 0);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4034, __pyx_L1_error)
}
__pyx_L63:;
- /* "netCDF4/_netCDF4.pyx":4032
+ /* "netCDF4/_netCDF4.pyx":4035
* msg="cannot assign fill_value for masked array when missing_value attribute is not a scalar"
* raise RuntimeError(msg)
* if numpy.array(fillval).shape != (): # <<<<<<<<<<<<<<
* fillval = fillval[0]
* elif hasattr(self, '_FillValue'):
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = NULL;
@@ -43170,42 +42819,42 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
}
if (!__pyx_t_5) {
- __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_fillval); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_fillval); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_fillval);
__Pyx_GIVEREF(__pyx_v_fillval);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_fillval);
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4035, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- __pyx_t_15 = PyObject_RichCompare(__pyx_t_2, __pyx_empty_tuple, Py_NE); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyObject_RichCompare(__pyx_t_2, __pyx_empty_tuple, Py_NE); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4035, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 4035, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":4033
+ /* "netCDF4/_netCDF4.pyx":4036
* raise RuntimeError(msg)
* if numpy.array(fillval).shape != ():
* fillval = fillval[0] # <<<<<<<<<<<<<<
* elif hasattr(self, '_FillValue'):
* fillval = self._FillValue
*/
- __pyx_t_15 = __Pyx_GetItemInt(__pyx_v_fillval, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_15 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4033; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_15 = __Pyx_GetItemInt(__pyx_v_fillval, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4036, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF_SET(__pyx_v_fillval, __pyx_t_15);
__pyx_t_15 = 0;
- /* "netCDF4/_netCDF4.pyx":4032
+ /* "netCDF4/_netCDF4.pyx":4035
* msg="cannot assign fill_value for masked array when missing_value attribute is not a scalar"
* raise RuntimeError(msg)
* if numpy.array(fillval).shape != (): # <<<<<<<<<<<<<<
@@ -43214,7 +42863,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":4023
+ /* "netCDF4/_netCDF4.pyx":4026
* data = data.data
* else:
* if hasattr(self, 'missing_value'): # <<<<<<<<<<<<<<
@@ -43224,30 +42873,30 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L62;
}
- /* "netCDF4/_netCDF4.pyx":4034
+ /* "netCDF4/_netCDF4.pyx":4037
* if numpy.array(fillval).shape != ():
* fillval = fillval[0]
* elif hasattr(self, '_FillValue'): # <<<<<<<<<<<<<<
* fillval = self._FillValue
* else:
*/
- __pyx_t_1 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(__pyx_t_1 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_HasAttr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(0, 4037, __pyx_L1_error)
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4035
+ /* "netCDF4/_netCDF4.pyx":4038
* fillval = fillval[0]
* elif hasattr(self, '_FillValue'):
* fillval = self._FillValue # <<<<<<<<<<<<<<
* else:
* fillval = default_fillvals[self.dtype.str[1:]]
*/
- __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_FillValue); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4038, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__pyx_v_fillval = __pyx_t_15;
__pyx_t_15 = 0;
- /* "netCDF4/_netCDF4.pyx":4034
+ /* "netCDF4/_netCDF4.pyx":4037
* if numpy.array(fillval).shape != ():
* fillval = fillval[0]
* elif hasattr(self, '_FillValue'): # <<<<<<<<<<<<<<
@@ -43257,7 +42906,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L62;
}
- /* "netCDF4/_netCDF4.pyx":4037
+ /* "netCDF4/_netCDF4.pyx":4040
* fillval = self._FillValue
* else:
* fillval = default_fillvals[self.dtype.str[1:]] # <<<<<<<<<<<<<<
@@ -43265,14 +42914,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*
*/
/*else*/ {
- __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_fillvals); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_fillvals); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->dtype, __pyx_n_s_str); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_2, 1, 0, NULL, NULL, &__pyx_slice__64, 1, 0, 1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_2, 1, 0, NULL, NULL, &__pyx_slice__62, 1, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyObject_GetItem(__pyx_t_15, __pyx_t_7); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4037; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_t_15, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -43281,19 +42930,19 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__pyx_L62:;
- /* "netCDF4/_netCDF4.pyx":4038
+ /* "netCDF4/_netCDF4.pyx":4041
* else:
* fillval = default_fillvals[self.dtype.str[1:]]
* data = data.filled(fill_value=fillval) # <<<<<<<<<<<<<<
*
* # Fill output array with data chunks.
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_filled); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4038; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_filled); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4041, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4038; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4041, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_fill_value, __pyx_v_fillval) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4038; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4038; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_fill_value, __pyx_v_fillval) < 0) __PYX_ERR(0, 4041, __pyx_L1_error)
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4041, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -43302,7 +42951,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__pyx_L59:;
- /* "netCDF4/_netCDF4.pyx":4015
+ /* "netCDF4/_netCDF4.pyx":4018
* data = data - self.add_offset
* if self.dtype.kind in 'iu': data = numpy.around(data)
* if ma.isMA(data): # <<<<<<<<<<<<<<
@@ -43311,7 +42960,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":4004
+ /* "netCDF4/_netCDF4.pyx":4007
* # if not masked, create a masked array.
* if not ma.isMA(data): data = self._toma(data)
* if self.scale and self._isprimitive: # <<<<<<<<<<<<<<
@@ -43320,14 +42969,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":4041
+ /* "netCDF4/_netCDF4.pyx":4044
*
* # Fill output array with data chunks.
* for (a,b,c,i) in zip(start, count, stride, put_ind): # <<<<<<<<<<<<<<
* dataput = data[tuple(i)]
* if dataput.size == 0: continue # nothing to write
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_2 = NULL;
__pyx_t_13 = 0;
@@ -43341,7 +42990,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_13 = 1;
}
}
- __pyx_t_5 = PyTuple_New(4+__pyx_t_13); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(4+__pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (__pyx_t_2) {
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2); __pyx_t_2 = NULL;
@@ -43358,7 +43007,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_put_ind);
__Pyx_GIVEREF(__pyx_v_put_ind);
PyTuple_SET_ITEM(__pyx_t_5, 3+__pyx_t_13, __pyx_v_put_ind);
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_5, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -43366,9 +43015,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_7 = __pyx_t_15; __Pyx_INCREF(__pyx_t_7); __pyx_t_13 = 0;
__pyx_t_11 = NULL;
} else {
- __pyx_t_13 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_11 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4044, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
for (;;) {
@@ -43376,17 +43025,17 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_15 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_15); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_15); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 4044, __pyx_L1_error)
#else
- __pyx_t_15 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
#endif
} else {
if (__pyx_t_13 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_15 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_15); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_15); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 4044, __pyx_L1_error)
#else
- __pyx_t_15 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
#endif
}
@@ -43396,7 +43045,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4044, __pyx_L1_error)
}
break;
}
@@ -43412,7 +43061,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
if (unlikely(size != 4)) {
if (size > 4) __Pyx_RaiseTooManyValuesError(4);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4044, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -43435,7 +43084,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
Py_ssize_t i;
PyObject** temps[4] = {&__pyx_t_5,&__pyx_t_2,&__pyx_t_10,&__pyx_t_6};
for (i=0; i < 4; i++) {
- PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 4044, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
@@ -43445,7 +43094,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
} else {
Py_ssize_t index = -1;
PyObject** temps[4] = {&__pyx_t_5,&__pyx_t_2,&__pyx_t_10,&__pyx_t_6};
- __pyx_t_14 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyObject_GetIter(__pyx_t_15); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 4044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__pyx_t_12 = Py_TYPE(__pyx_t_14)->tp_iternext;
@@ -43454,7 +43103,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_14), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_12(__pyx_t_14), 4) < 0) __PYX_ERR(0, 4044, __pyx_L1_error)
__pyx_t_12 = NULL;
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
goto __pyx_L68_unpacking_done;
@@ -43462,7 +43111,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__pyx_t_12 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4044, __pyx_L1_error)
__pyx_L68_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_a, __pyx_t_5);
@@ -43474,74 +43123,74 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_6);
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":4042
+ /* "netCDF4/_netCDF4.pyx":4045
* # Fill output array with data chunks.
* for (a,b,c,i) in zip(start, count, stride, put_ind):
* dataput = data[tuple(i)] # <<<<<<<<<<<<<<
* if dataput.size == 0: continue # nothing to write
* # convert array scalar to regular array with one element.
*/
- __pyx_t_15 = PySequence_Tuple(__pyx_v_i); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4042; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PySequence_Tuple(__pyx_v_i); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- __pyx_t_6 = PyObject_GetItem(__pyx_v_data, __pyx_t_15); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4042; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_6 = PyObject_GetItem(__pyx_v_data, __pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_XDECREF_SET(__pyx_v_dataput, __pyx_t_6);
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":4043
+ /* "netCDF4/_netCDF4.pyx":4046
* for (a,b,c,i) in zip(start, count, stride, put_ind):
* dataput = data[tuple(i)]
* if dataput.size == 0: continue # nothing to write # <<<<<<<<<<<<<<
* # convert array scalar to regular array with one element.
* if dataput.shape == ():
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dataput, __pyx_n_s_size); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4043; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dataput, __pyx_n_s_size); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4046, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_15 = __Pyx_PyInt_EqObjC(__pyx_t_6, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4043; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyInt_EqObjC(__pyx_t_6, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4046, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4043; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4046, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
if (__pyx_t_3) {
goto __pyx_L65_continue;
}
- /* "netCDF4/_netCDF4.pyx":4045
+ /* "netCDF4/_netCDF4.pyx":4048
* if dataput.size == 0: continue # nothing to write
* # convert array scalar to regular array with one element.
* if dataput.shape == (): # <<<<<<<<<<<<<<
* if self._isvlen:
* dataput=numpy.array(dataput,'O')
*/
- __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_dataput, __pyx_n_s_shape); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4045; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_dataput, __pyx_n_s_shape); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4048, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- __pyx_t_6 = PyObject_RichCompare(__pyx_t_15, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4045; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_RichCompare(__pyx_t_15, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4048, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4045; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4048, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4046
+ /* "netCDF4/_netCDF4.pyx":4049
* # convert array scalar to regular array with one element.
* if dataput.shape == ():
* if self._isvlen: # <<<<<<<<<<<<<<
* dataput=numpy.array(dataput,'O')
* else:
*/
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4046; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4049, __pyx_L1_error)
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4047
+ /* "netCDF4/_netCDF4.pyx":4050
* if dataput.shape == ():
* if self._isvlen:
* dataput=numpy.array(dataput,'O') # <<<<<<<<<<<<<<
* else:
* dataput=numpy.array(dataput,dataput.dtype)
*/
- __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4050, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_array); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_array); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4050, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__pyx_t_15 = NULL;
@@ -43556,7 +43205,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_2 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4050, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (__pyx_t_15) {
__Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_15); __pyx_t_15 = NULL;
@@ -43567,14 +43216,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_n_s_O);
__Pyx_GIVEREF(__pyx_n_s_O);
PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_4, __pyx_n_s_O);
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_2, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4047; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_2, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4050, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF_SET(__pyx_v_dataput, __pyx_t_6);
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":4046
+ /* "netCDF4/_netCDF4.pyx":4049
* # convert array scalar to regular array with one element.
* if dataput.shape == ():
* if self._isvlen: # <<<<<<<<<<<<<<
@@ -43584,7 +43233,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
goto __pyx_L71;
}
- /* "netCDF4/_netCDF4.pyx":4049
+ /* "netCDF4/_netCDF4.pyx":4052
* dataput=numpy.array(dataput,'O')
* else:
* dataput=numpy.array(dataput,dataput.dtype) # <<<<<<<<<<<<<<
@@ -43592,12 +43241,12 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*
*/
/*else*/ {
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4052, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4052, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_dataput, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_dataput, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4052, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_15 = NULL;
__pyx_t_4 = 0;
@@ -43611,7 +43260,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4052, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (__pyx_t_15) {
__Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_15); __pyx_t_15 = NULL;
@@ -43622,7 +43271,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_4, __pyx_t_10);
__pyx_t_10 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4052, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -43631,7 +43280,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__pyx_L71:;
- /* "netCDF4/_netCDF4.pyx":4045
+ /* "netCDF4/_netCDF4.pyx":4048
* if dataput.size == 0: continue # nothing to write
* # convert array scalar to regular array with one element.
* if dataput.shape == (): # <<<<<<<<<<<<<<
@@ -43640,14 +43289,14 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
*/
}
- /* "netCDF4/_netCDF4.pyx":4050
+ /* "netCDF4/_netCDF4.pyx":4053
* else:
* dataput=numpy.array(dataput,dataput.dtype)
* self._put(dataput,a,b,c) # <<<<<<<<<<<<<<
*
*
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_put_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4050; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_put_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4053, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_5 = NULL;
__pyx_t_4 = 0;
@@ -43661,7 +43310,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__pyx_t_4 = 1;
}
}
- __pyx_t_10 = PyTuple_New(4+__pyx_t_4); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4050; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(4+__pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4053, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); __pyx_t_5 = NULL;
@@ -43678,13 +43327,13 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
__Pyx_INCREF(__pyx_v_c);
__Pyx_GIVEREF(__pyx_v_c);
PyTuple_SET_ITEM(__pyx_t_10, 3+__pyx_t_4, __pyx_v_c);
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4050; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4053, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":4041
+ /* "netCDF4/_netCDF4.pyx":4044
*
* # Fill output array with data chunks.
* for (a,b,c,i) in zip(start, count, stride, put_ind): # <<<<<<<<<<<<<<
@@ -43695,7 +43344,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":3908
+ /* "netCDF4/_netCDF4.pyx":3911
* free(countp)
*
* def __setitem__(self, elem, data): # <<<<<<<<<<<<<<
@@ -43738,7 +43387,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_50__setitem__(struct __pyx_obj_
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":4053
+/* "netCDF4/_netCDF4.pyx":4056
*
*
* def __len__(self): # <<<<<<<<<<<<<<
@@ -43767,39 +43416,36 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_8Variable_52__len__(struct __pyx_o
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
Py_ssize_t __pyx_t_5;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__len__", 0);
- /* "netCDF4/_netCDF4.pyx":4054
+ /* "netCDF4/_netCDF4.pyx":4057
*
* def __len__(self):
* if not self.shape: # <<<<<<<<<<<<<<
* raise TypeError('len() of unsized object')
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4057, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4057, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = ((!__pyx_t_2) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4055
+ /* "netCDF4/_netCDF4.pyx":4058
* def __len__(self):
* if not self.shape:
* raise TypeError('len() of unsized object') # <<<<<<<<<<<<<<
* else:
* return self.shape[0]
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4058, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4058, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4054
+ /* "netCDF4/_netCDF4.pyx":4057
*
* def __len__(self):
* if not self.shape: # <<<<<<<<<<<<<<
@@ -43808,7 +43454,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_8Variable_52__len__(struct __pyx_o
*/
}
- /* "netCDF4/_netCDF4.pyx":4057
+ /* "netCDF4/_netCDF4.pyx":4060
* raise TypeError('len() of unsized object')
* else:
* return self.shape[0] # <<<<<<<<<<<<<<
@@ -43816,18 +43462,18 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_8Variable_52__len__(struct __pyx_o
*
*/
/*else*/ {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4060, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4057; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4060, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_4); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyIndex_AsSsize_t(__pyx_t_4); if (unlikely((__pyx_t_5 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4060, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __pyx_t_5;
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":4053
+ /* "netCDF4/_netCDF4.pyx":4056
*
*
* def __len__(self): # <<<<<<<<<<<<<<
@@ -43846,7 +43492,7 @@ static Py_ssize_t __pyx_pf_7netCDF4_8_netCDF4_8Variable_52__len__(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":4060
+/* "netCDF4/_netCDF4.pyx":4063
*
*
* def assignValue(self,val): # <<<<<<<<<<<<<<
@@ -43874,39 +43520,36 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_54assignValue(struct __py
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("assignValue", 0);
- /* "netCDF4/_netCDF4.pyx":4066
+ /* "netCDF4/_netCDF4.pyx":4069
* assign a value to a scalar variable. Provided for compatibility with
* Scientific.IO.NetCDF, can also be done by assigning to an Ellipsis slice ([...])."""
* if len(self.dimensions): # <<<<<<<<<<<<<<
* raise IndexError('to assign values to a non-scalar variable, use a slice')
* self[:]=val
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4066; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4069, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4066; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 4069, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4067
+ /* "netCDF4/_netCDF4.pyx":4070
* Scientific.IO.NetCDF, can also be done by assigning to an Ellipsis slice ([...])."""
* if len(self.dimensions):
* raise IndexError('to assign values to a non-scalar variable, use a slice') # <<<<<<<<<<<<<<
* self[:]=val
*
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4067; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__64, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4070, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4067; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4070, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4066
+ /* "netCDF4/_netCDF4.pyx":4069
* assign a value to a scalar variable. Provided for compatibility with
* Scientific.IO.NetCDF, can also be done by assigning to an Ellipsis slice ([...])."""
* if len(self.dimensions): # <<<<<<<<<<<<<<
@@ -43915,16 +43558,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_54assignValue(struct __py
*/
}
- /* "netCDF4/_netCDF4.pyx":4068
+ /* "netCDF4/_netCDF4.pyx":4071
* if len(self.dimensions):
* raise IndexError('to assign values to a non-scalar variable, use a slice')
* self[:]=val # <<<<<<<<<<<<<<
*
* def getValue(self):
*/
- if (__Pyx_PyObject_SetSlice(((PyObject *)__pyx_v_self), __pyx_v_val, 0, 0, NULL, NULL, &__pyx_slice__67, 0, 0, 1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4068; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetSlice(((PyObject *)__pyx_v_self), __pyx_v_val, 0, 0, NULL, NULL, &__pyx_slice__65, 0, 0, 1) < 0) __PYX_ERR(0, 4071, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4060
+ /* "netCDF4/_netCDF4.pyx":4063
*
*
* def assignValue(self,val): # <<<<<<<<<<<<<<
@@ -43945,7 +43588,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_54assignValue(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":4070
+/* "netCDF4/_netCDF4.pyx":4073
* self[:]=val
*
* def getValue(self): # <<<<<<<<<<<<<<
@@ -43973,39 +43616,36 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_56getValue(struct __pyx_o
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("getValue", 0);
- /* "netCDF4/_netCDF4.pyx":4076
+ /* "netCDF4/_netCDF4.pyx":4079
* get the value of a scalar variable. Provided for compatibility with
* Scientific.IO.NetCDF, can also be done by slicing with an Ellipsis ([...])."""
* if len(self.dimensions): # <<<<<<<<<<<<<<
* raise IndexError('to retrieve values from a non-scalar variable, use slicing')
* return self[slice(None)]
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4076; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4079, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4076; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 4079, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4077
+ /* "netCDF4/_netCDF4.pyx":4080
* Scientific.IO.NetCDF, can also be done by slicing with an Ellipsis ([...])."""
* if len(self.dimensions):
* raise IndexError('to retrieve values from a non-scalar variable, use slicing') # <<<<<<<<<<<<<<
* return self[slice(None)]
*
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4077; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4080, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4077; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4080, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4076
+ /* "netCDF4/_netCDF4.pyx":4079
* get the value of a scalar variable. Provided for compatibility with
* Scientific.IO.NetCDF, can also be done by slicing with an Ellipsis ([...])."""
* if len(self.dimensions): # <<<<<<<<<<<<<<
@@ -44014,7 +43654,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_56getValue(struct __pyx_o
*/
}
- /* "netCDF4/_netCDF4.pyx":4078
+ /* "netCDF4/_netCDF4.pyx":4081
* if len(self.dimensions):
* raise IndexError('to retrieve values from a non-scalar variable, use slicing')
* return self[slice(None)] # <<<<<<<<<<<<<<
@@ -44022,13 +43662,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_56getValue(struct __pyx_o
* def set_auto_maskandscale(self,maskandscale):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_slice__69); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4078; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_slice__67); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4081, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
- /* "netCDF4/_netCDF4.pyx":4070
+ /* "netCDF4/_netCDF4.pyx":4073
* self[:]=val
*
* def getValue(self): # <<<<<<<<<<<<<<
@@ -44047,7 +43687,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_56getValue(struct __pyx_o
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":4080
+/* "netCDF4/_netCDF4.pyx":4083
* return self[slice(None)]
*
* def set_auto_maskandscale(self,maskandscale): # <<<<<<<<<<<<<<
@@ -44073,22 +43713,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_58set_auto_maskandscale(s
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_auto_maskandscale", 0);
- /* "netCDF4/_netCDF4.pyx":4120
+ /* "netCDF4/_netCDF4.pyx":4123
* (automatic conversions are performed).
* """
* if maskandscale: # <<<<<<<<<<<<<<
* self.scale = True
* self.mask = True
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_maskandscale); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4120; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_maskandscale); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 4123, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":4121
+ /* "netCDF4/_netCDF4.pyx":4124
* """
* if maskandscale:
* self.scale = True # <<<<<<<<<<<<<<
@@ -44101,7 +43738,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_58set_auto_maskandscale(s
__Pyx_DECREF(__pyx_v_self->scale);
__pyx_v_self->scale = Py_True;
- /* "netCDF4/_netCDF4.pyx":4122
+ /* "netCDF4/_netCDF4.pyx":4125
* if maskandscale:
* self.scale = True
* self.mask = True # <<<<<<<<<<<<<<
@@ -44114,7 +43751,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_58set_auto_maskandscale(s
__Pyx_DECREF(__pyx_v_self->mask);
__pyx_v_self->mask = Py_True;
- /* "netCDF4/_netCDF4.pyx":4120
+ /* "netCDF4/_netCDF4.pyx":4123
* (automatic conversions are performed).
* """
* if maskandscale: # <<<<<<<<<<<<<<
@@ -44124,7 +43761,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_58set_auto_maskandscale(s
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":4124
+ /* "netCDF4/_netCDF4.pyx":4127
* self.mask = True
* else:
* self.scale = False # <<<<<<<<<<<<<<
@@ -44138,7 +43775,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_58set_auto_maskandscale(s
__Pyx_DECREF(__pyx_v_self->scale);
__pyx_v_self->scale = Py_False;
- /* "netCDF4/_netCDF4.pyx":4125
+ /* "netCDF4/_netCDF4.pyx":4128
* else:
* self.scale = False
* self.mask = False # <<<<<<<<<<<<<<
@@ -44153,7 +43790,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_58set_auto_maskandscale(s
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":4080
+ /* "netCDF4/_netCDF4.pyx":4083
* return self[slice(None)]
*
* def set_auto_maskandscale(self,maskandscale): # <<<<<<<<<<<<<<
@@ -44173,7 +43810,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_58set_auto_maskandscale(s
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":4127
+/* "netCDF4/_netCDF4.pyx":4130
* self.mask = False
*
* def set_auto_scale(self,scale): # <<<<<<<<<<<<<<
@@ -44199,22 +43836,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_60set_auto_scale(struct _
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_auto_scale", 0);
- /* "netCDF4/_netCDF4.pyx":4154
+ /* "netCDF4/_netCDF4.pyx":4157
* (automatic conversions are performed).
* """
* if scale: # <<<<<<<<<<<<<<
* self.scale = True
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_scale); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4154; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_scale); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 4157, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":4155
+ /* "netCDF4/_netCDF4.pyx":4158
* """
* if scale:
* self.scale = True # <<<<<<<<<<<<<<
@@ -44227,7 +43861,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_60set_auto_scale(struct _
__Pyx_DECREF(__pyx_v_self->scale);
__pyx_v_self->scale = Py_True;
- /* "netCDF4/_netCDF4.pyx":4154
+ /* "netCDF4/_netCDF4.pyx":4157
* (automatic conversions are performed).
* """
* if scale: # <<<<<<<<<<<<<<
@@ -44237,7 +43871,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_60set_auto_scale(struct _
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":4157
+ /* "netCDF4/_netCDF4.pyx":4160
* self.scale = True
* else:
* self.scale = False # <<<<<<<<<<<<<<
@@ -44253,7 +43887,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_60set_auto_scale(struct _
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":4127
+ /* "netCDF4/_netCDF4.pyx":4130
* self.mask = False
*
* def set_auto_scale(self,scale): # <<<<<<<<<<<<<<
@@ -44273,7 +43907,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_60set_auto_scale(struct _
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":4159
+/* "netCDF4/_netCDF4.pyx":4162
* self.scale = False
*
* def set_auto_mask(self,mask): # <<<<<<<<<<<<<<
@@ -44299,22 +43933,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_62set_auto_mask(struct __
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_auto_mask", 0);
- /* "netCDF4/_netCDF4.pyx":4181
+ /* "netCDF4/_netCDF4.pyx":4184
* (automatic conversions are performed).
* """
* if mask: # <<<<<<<<<<<<<<
* self.mask = True
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_mask); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4181; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_mask); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 4184, __pyx_L1_error)
if (__pyx_t_1) {
- /* "netCDF4/_netCDF4.pyx":4182
+ /* "netCDF4/_netCDF4.pyx":4185
* """
* if mask:
* self.mask = True # <<<<<<<<<<<<<<
@@ -44327,7 +43958,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_62set_auto_mask(struct __
__Pyx_DECREF(__pyx_v_self->mask);
__pyx_v_self->mask = Py_True;
- /* "netCDF4/_netCDF4.pyx":4181
+ /* "netCDF4/_netCDF4.pyx":4184
* (automatic conversions are performed).
* """
* if mask: # <<<<<<<<<<<<<<
@@ -44337,7 +43968,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_62set_auto_mask(struct __
goto __pyx_L3;
}
- /* "netCDF4/_netCDF4.pyx":4184
+ /* "netCDF4/_netCDF4.pyx":4187
* self.mask = True
* else:
* self.mask = False # <<<<<<<<<<<<<<
@@ -44353,7 +43984,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_62set_auto_mask(struct __
}
__pyx_L3:;
- /* "netCDF4/_netCDF4.pyx":4159
+ /* "netCDF4/_netCDF4.pyx":4162
* self.scale = False
*
* def set_auto_mask(self,mask): # <<<<<<<<<<<<<<
@@ -44373,7 +44004,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_62set_auto_mask(struct __
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":4187
+/* "netCDF4/_netCDF4.pyx":4190
*
*
* def _put(self,ndarray data,start,count,stride): # <<<<<<<<<<<<<<
@@ -44389,9 +44020,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_65_put(PyObject *__pyx_v_
PyObject *__pyx_v_start = 0;
PyObject *__pyx_v_count = 0;
PyObject *__pyx_v_stride = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_put (wrapper)", 0);
@@ -44417,21 +44045,21 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_65_put(PyObject *__pyx_v_
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("_put", 1, 4, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4187; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_put", 1, 4, 4, 1); __PYX_ERR(0, 4190, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_count)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("_put", 1, 4, 4, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4187; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_put", 1, 4, 4, 2); __PYX_ERR(0, 4190, __pyx_L3_error)
}
case 3:
if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_stride)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("_put", 1, 4, 4, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4187; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_put", 1, 4, 4, 3); __PYX_ERR(0, 4190, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_put") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4187; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_put") < 0)) __PYX_ERR(0, 4190, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
goto __pyx_L5_argtuple_error;
@@ -44448,13 +44076,13 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_65_put(PyObject *__pyx_v_
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("_put", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4187; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_put", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4190, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Variable._put", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
- if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_data), __pyx_ptype_7netCDF4_8_netCDF4_ndarray, 1, "data", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4187; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_data), __pyx_ptype_7netCDF4_8_netCDF4_ndarray, 1, "data", 0))) __PYX_ERR(0, 4190, __pyx_L1_error)
__pyx_r = __pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(((struct __pyx_obj_7netCDF4_8_netCDF4_Variable *)__pyx_v_self), __pyx_v_data, __pyx_v_start, __pyx_v_count, __pyx_v_stride);
/* function exit code */
@@ -44497,30 +44125,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
PyObject *__pyx_t_10 = NULL;
int __pyx_t_11;
int __pyx_t_12;
- int __pyx_t_13;
- char *__pyx_t_14;
- PyObject *(*__pyx_t_15)(PyObject *);
- npy_intp __pyx_t_16;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
+ char *__pyx_t_13;
+ PyObject *(*__pyx_t_14)(PyObject *);
+ npy_intp __pyx_t_15;
__Pyx_RefNannySetupContext("_put", 0);
__Pyx_INCREF((PyObject *)__pyx_v_data);
- /* "netCDF4/_netCDF4.pyx":4200
+ /* "netCDF4/_netCDF4.pyx":4203
* cdef nc_vlen_t *vldata
* # rank of variable.
* ndims = len(self.dimensions) # <<<<<<<<<<<<<<
* # make sure data is contiguous.
* # if not, make a local copy.
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4200; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4203, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4200; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 4203, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_ndims = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":4203
+ /* "netCDF4/_netCDF4.pyx":4206
* # make sure data is contiguous.
* # if not, make a local copy.
* if not PyArray_ISCONTIGUOUS(data): # <<<<<<<<<<<<<<
@@ -44530,14 +44154,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__pyx_t_3 = ((!(PyArray_ISCONTIGUOUS(__pyx_v_data) != 0)) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4204
+ /* "netCDF4/_netCDF4.pyx":4207
* # if not, make a local copy.
* if not PyArray_ISCONTIGUOUS(data):
* data = data.copy() # <<<<<<<<<<<<<<
* # fill up startp,countp,stridep.
* totelem = 1
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4207, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -44550,18 +44174,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4207, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4207, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4204; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4207, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_1));
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4203
+ /* "netCDF4/_netCDF4.pyx":4206
* # make sure data is contiguous.
* # if not, make a local copy.
* if not PyArray_ISCONTIGUOUS(data): # <<<<<<<<<<<<<<
@@ -44570,7 +44194,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4206
+ /* "netCDF4/_netCDF4.pyx":4209
* data = data.copy()
* # fill up startp,countp,stridep.
* totelem = 1 # <<<<<<<<<<<<<<
@@ -44579,7 +44203,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_totelem = 1;
- /* "netCDF4/_netCDF4.pyx":4207
+ /* "netCDF4/_netCDF4.pyx":4210
* # fill up startp,countp,stridep.
* totelem = 1
* negstride = 0 # <<<<<<<<<<<<<<
@@ -44588,19 +44212,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_negstride = 0;
- /* "netCDF4/_netCDF4.pyx":4208
+ /* "netCDF4/_netCDF4.pyx":4211
* totelem = 1
* negstride = 0
* sl = [] # <<<<<<<<<<<<<<
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4208; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_sl = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4209
+ /* "netCDF4/_netCDF4.pyx":4212
* negstride = 0
* sl = []
* startp = <size_t *>malloc(sizeof(size_t) * ndims) # <<<<<<<<<<<<<<
@@ -44609,7 +44233,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_startp = ((size_t *)malloc(((sizeof(size_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":4210
+ /* "netCDF4/_netCDF4.pyx":4213
* sl = []
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims) # <<<<<<<<<<<<<<
@@ -44618,7 +44242,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_countp = ((size_t *)malloc(((sizeof(size_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":4211
+ /* "netCDF4/_netCDF4.pyx":4214
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
* stridep = <ptrdiff_t *>malloc(sizeof(ptrdiff_t) * ndims) # <<<<<<<<<<<<<<
@@ -44627,7 +44251,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_stridep = ((ptrdiff_t *)malloc(((sizeof(ptrdiff_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":4212
+ /* "netCDF4/_netCDF4.pyx":4215
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
* stridep = <ptrdiff_t *>malloc(sizeof(ptrdiff_t) * ndims)
* for n from 0 <= n < ndims: # <<<<<<<<<<<<<<
@@ -44636,56 +44260,56 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_t_6 = __pyx_v_ndims;
for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7++) {
- __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4212; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4213
+ /* "netCDF4/_netCDF4.pyx":4216
* stridep = <ptrdiff_t *>malloc(sizeof(ptrdiff_t) * ndims)
* for n from 0 <= n < ndims:
* count[n] = abs(count[n]) # make -1 into +1 # <<<<<<<<<<<<<<
* countp[n] = count[n]
* # for neg strides, reverse order (then flip that axis after data read in)
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_count, __pyx_v_n); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4213; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_count, __pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4216, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyNumber_Absolute(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Absolute(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4216, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_count, __pyx_v_n, __pyx_t_4) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_count, __pyx_v_n, __pyx_t_4) < 0)) __PYX_ERR(0, 4216, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4214
+ /* "netCDF4/_netCDF4.pyx":4217
* for n from 0 <= n < ndims:
* count[n] = abs(count[n]) # make -1 into +1
* countp[n] = count[n] # <<<<<<<<<<<<<<
* # for neg strides, reverse order (then flip that axis after data read in)
* if stride[n] < 0:
*/
- __pyx_t_4 = PyObject_GetItem(__pyx_v_count, __pyx_v_n); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4214; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_count, __pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4217, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4217, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4217, __pyx_L1_error)
(__pyx_v_countp[__pyx_t_2]) = __pyx_t_8;
- /* "netCDF4/_netCDF4.pyx":4216
+ /* "netCDF4/_netCDF4.pyx":4219
* countp[n] = count[n]
* # for neg strides, reverse order (then flip that axis after data read in)
* if stride[n] < 0: # <<<<<<<<<<<<<<
* negstride = 1
* stridep[n] = -stride[n]
*/
- __pyx_t_4 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4216; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4219, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4216; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_4, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4219, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4216; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4219, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4217
+ /* "netCDF4/_netCDF4.pyx":4220
* # for neg strides, reverse order (then flip that axis after data read in)
* if stride[n] < 0:
* negstride = 1 # <<<<<<<<<<<<<<
@@ -44694,77 +44318,77 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_negstride = 1;
- /* "netCDF4/_netCDF4.pyx":4218
+ /* "netCDF4/_netCDF4.pyx":4221
* if stride[n] < 0:
* negstride = 1
* stridep[n] = -stride[n] # <<<<<<<<<<<<<<
* startp[n] = start[n]+stride[n]*(count[n]-1)
* stride[n] = -stride[n]
*/
- __pyx_t_1 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4218; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4221, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4218; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4221, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_9 = __Pyx_PyInt_As_ptrdiff_t(__pyx_t_4); if (unlikely((__pyx_t_9 == (ptrdiff_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4218; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_ptrdiff_t(__pyx_t_4); if (unlikely((__pyx_t_9 == (ptrdiff_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4221, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4218; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4221, __pyx_L1_error)
(__pyx_v_stridep[__pyx_t_2]) = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":4219
+ /* "netCDF4/_netCDF4.pyx":4222
* negstride = 1
* stridep[n] = -stride[n]
* startp[n] = start[n]+stride[n]*(count[n]-1) # <<<<<<<<<<<<<<
* stride[n] = -stride[n]
* sl.append(slice(None, None, -1)) # this slice will reverse the data
*/
- __pyx_t_4 = PyObject_GetItem(__pyx_v_start, __pyx_v_n); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4219; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_start, __pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4219; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyObject_GetItem(__pyx_v_count, __pyx_v_n); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4219; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = PyObject_GetItem(__pyx_v_count, __pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_10 = __Pyx_PyInt_SubtractObjC(__pyx_t_5, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_SubtractObjC(__pyx_t_5, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyNumber_Multiply(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyNumber_Multiply(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyNumber_Add(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4222, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_10); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_10); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4222, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4222, __pyx_L1_error)
(__pyx_v_startp[__pyx_t_2]) = __pyx_t_8;
- /* "netCDF4/_netCDF4.pyx":4220
+ /* "netCDF4/_netCDF4.pyx":4223
* stridep[n] = -stride[n]
* startp[n] = start[n]+stride[n]*(count[n]-1)
* stride[n] = -stride[n] # <<<<<<<<<<<<<<
* sl.append(slice(None, None, -1)) # this slice will reverse the data
* else:
*/
- __pyx_t_10 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4220; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_10 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_5 = PyNumber_Negative(__pyx_t_10); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyNumber_Negative(__pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4223, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- if (unlikely(PyObject_SetItem(__pyx_v_stride, __pyx_v_n, __pyx_t_5) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_stride, __pyx_v_n, __pyx_t_5) < 0)) __PYX_ERR(0, 4223, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":4221
+ /* "netCDF4/_netCDF4.pyx":4224
* startp[n] = start[n]+stride[n]*(count[n]-1)
* stride[n] = -stride[n]
* sl.append(slice(None, None, -1)) # this slice will reverse the data # <<<<<<<<<<<<<<
* else:
* startp[n] = start[n]
*/
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_sl, __pyx_slice__70); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4221; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_sl, __pyx_slice__68); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 4224, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4216
+ /* "netCDF4/_netCDF4.pyx":4219
* countp[n] = count[n]
* # for neg strides, reverse order (then flip that axis after data read in)
* if stride[n] < 0: # <<<<<<<<<<<<<<
@@ -44774,7 +44398,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
goto __pyx_L6;
}
- /* "netCDF4/_netCDF4.pyx":4223
+ /* "netCDF4/_netCDF4.pyx":4226
* sl.append(slice(None, None, -1)) # this slice will reverse the data
* else:
* startp[n] = start[n] # <<<<<<<<<<<<<<
@@ -44782,63 +44406,63 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
* sl.append(slice(None,None, 1))
*/
/*else*/ {
- __pyx_t_5 = PyObject_GetItem(__pyx_v_start, __pyx_v_n); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4223; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = PyObject_GetItem(__pyx_v_start, __pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4226, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_5); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4223; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_5); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4226, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4223; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4226, __pyx_L1_error)
(__pyx_v_startp[__pyx_t_2]) = __pyx_t_8;
- /* "netCDF4/_netCDF4.pyx":4224
+ /* "netCDF4/_netCDF4.pyx":4227
* else:
* startp[n] = start[n]
* stridep[n] = stride[n] # <<<<<<<<<<<<<<
* sl.append(slice(None,None, 1))
* totelem = totelem*countp[n]
*/
- __pyx_t_5 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4224; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_9 = __Pyx_PyInt_As_ptrdiff_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (ptrdiff_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4224; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_ptrdiff_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (ptrdiff_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4227, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4224; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4227, __pyx_L1_error)
(__pyx_v_stridep[__pyx_t_2]) = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":4225
+ /* "netCDF4/_netCDF4.pyx":4228
* startp[n] = start[n]
* stridep[n] = stride[n]
* sl.append(slice(None,None, 1)) # <<<<<<<<<<<<<<
* totelem = totelem*countp[n]
* # check to see that size of data array is what is expected
*/
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_sl, __pyx_slice__71); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_sl, __pyx_slice__69); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 4228, __pyx_L1_error)
}
__pyx_L6:;
- /* "netCDF4/_netCDF4.pyx":4226
+ /* "netCDF4/_netCDF4.pyx":4229
* stridep[n] = stride[n]
* sl.append(slice(None,None, 1))
* totelem = totelem*countp[n] # <<<<<<<<<<<<<<
* # check to see that size of data array is what is expected
* # for slice given.
*/
- __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4226; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_v_n); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4229, __pyx_L1_error)
__pyx_v_totelem = (__pyx_v_totelem * (__pyx_v_countp[__pyx_t_2]));
- __pyx_t_7 = __Pyx_PyInt_As_long(__pyx_v_n); if (unlikely((__pyx_t_7 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4212; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_long(__pyx_v_n); if (unlikely((__pyx_t_7 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 4215, __pyx_L1_error)
}
- /* "netCDF4/_netCDF4.pyx":4212
+ /* "netCDF4/_netCDF4.pyx":4215
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
* stridep = <ptrdiff_t *>malloc(sizeof(ptrdiff_t) * ndims)
* for n from 0 <= n < ndims: # <<<<<<<<<<<<<<
* count[n] = abs(count[n]) # make -1 into +1
* countp[n] = count[n]
*/
- __pyx_t_5 = __Pyx_PyInt_From_long(__pyx_t_7); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4212; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyInt_From_long(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_5);
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":4229
+ /* "netCDF4/_netCDF4.pyx":4232
* # check to see that size of data array is what is expected
* # for slice given.
* dataelem = PyArray_SIZE(data) # <<<<<<<<<<<<<<
@@ -44847,7 +44471,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_dataelem = PyArray_SIZE(__pyx_v_data);
- /* "netCDF4/_netCDF4.pyx":4230
+ /* "netCDF4/_netCDF4.pyx":4233
* # for slice given.
* dataelem = PyArray_SIZE(data)
* if totelem != dataelem: # <<<<<<<<<<<<<<
@@ -44857,20 +44481,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__pyx_t_3 = ((__pyx_v_totelem != __pyx_v_dataelem) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4231
+ /* "netCDF4/_netCDF4.pyx":4234
* dataelem = PyArray_SIZE(data)
* if totelem != dataelem:
* raise IndexError('size of data array does not conform to slice') # <<<<<<<<<<<<<<
* if negstride:
* # reverse data along axes with negative strides.
*/
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4234, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4234, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4230
+ /* "netCDF4/_netCDF4.pyx":4233
* # for slice given.
* dataelem = PyArray_SIZE(data)
* if totelem != dataelem: # <<<<<<<<<<<<<<
@@ -44879,7 +44503,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4232
+ /* "netCDF4/_netCDF4.pyx":4235
* if totelem != dataelem:
* raise IndexError('size of data array does not conform to slice')
* if negstride: # <<<<<<<<<<<<<<
@@ -44889,16 +44513,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__pyx_t_3 = (__pyx_v_negstride != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4234
+ /* "netCDF4/_netCDF4.pyx":4237
* if negstride:
* # reverse data along axes with negative strides.
* data = data[sl].copy() # make sure a copy is made. # <<<<<<<<<<<<<<
* if self._isprimitive or self._iscompound or self._isenum:
* # primitive, enum or compound data type.
*/
- __pyx_t_10 = PyObject_GetItem(((PyObject *)__pyx_v_data), __pyx_v_sl); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4234; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_10 = PyObject_GetItem(((PyObject *)__pyx_v_data), __pyx_v_sl); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4237, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4234; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_copy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4237, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = NULL;
@@ -44912,18 +44536,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
}
}
if (__pyx_t_10) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4234; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4237, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4234; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4237, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4234; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4237, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_5));
__pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":4232
+ /* "netCDF4/_netCDF4.pyx":4235
* if totelem != dataelem:
* raise IndexError('size of data array does not conform to slice')
* if negstride: # <<<<<<<<<<<<<<
@@ -44932,53 +44556,53 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4235
+ /* "netCDF4/_netCDF4.pyx":4238
* # reverse data along axes with negative strides.
* data = data[sl].copy() # make sure a copy is made.
* if self._isprimitive or self._iscompound or self._isenum: # <<<<<<<<<<<<<<
* # primitive, enum or compound data type.
* # if data type of array doesn't match variable,
*/
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4238, __pyx_L1_error)
if (!__pyx_t_12) {
} else {
__pyx_t_3 = __pyx_t_12;
goto __pyx_L10_bool_binop_done;
}
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4238, __pyx_L1_error)
if (!__pyx_t_12) {
} else {
__pyx_t_3 = __pyx_t_12;
goto __pyx_L10_bool_binop_done;
}
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4238, __pyx_L1_error)
__pyx_t_3 = __pyx_t_12;
__pyx_L10_bool_binop_done:;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4239
+ /* "netCDF4/_netCDF4.pyx":4242
* # if data type of array doesn't match variable,
* # try to cast the data.
* if self.dtype != data.dtype: # <<<<<<<<<<<<<<
* data = data.astype(self.dtype) # cast data, if necessary.
- * # make sure byte-order of data matches byte-order of netcdf
+ * # byte-swap data in numpy array so that is has native
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4239; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4242, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PyObject_RichCompare(__pyx_v_self->dtype, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4239; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_self->dtype, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4242, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4239; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4242, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4240
+ /* "netCDF4/_netCDF4.pyx":4243
* # try to cast the data.
* if self.dtype != data.dtype:
* data = data.astype(self.dtype) # cast data, if necessary. # <<<<<<<<<<<<<<
- * # make sure byte-order of data matches byte-order of netcdf
- * # variable.
+ * # byte-swap data in numpy array so that is has native
+ * # endian byte order (this is what netcdf-c expects -
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_astype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4240; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_astype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_10 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -44991,504 +44615,170 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
}
}
if (!__pyx_t_10) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_self->dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4240; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_self->dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
- __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4240; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_10); __pyx_t_10 = NULL;
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_v_self->dtype);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4240; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4240; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4243, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_4));
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4239
+ /* "netCDF4/_netCDF4.pyx":4242
* # if data type of array doesn't match variable,
* # try to cast the data.
* if self.dtype != data.dtype: # <<<<<<<<<<<<<<
* data = data.astype(self.dtype) # cast data, if necessary.
- * # make sure byte-order of data matches byte-order of netcdf
+ * # byte-swap data in numpy array so that is has native
*/
}
- /* "netCDF4/_netCDF4.pyx":4243
- * # make sure byte-order of data matches byte-order of netcdf
- * # variable.
- * if self.endian() == 'native': # <<<<<<<<<<<<<<
- * if is_native_little and data.dtype.byteorder == '>':
- * data.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":4247
+ * # endian byte order (this is what netcdf-c expects -
+ * # issue #554, pull request #555)
+ * if (is_native_little and data.dtype.byteorder == '>') or\ # <<<<<<<<<<<<<<
+ * (is_native_big and data.dtype.byteorder == '<'):
+ * data = data.byteswap() # don't do in-place, make a copy
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_1)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_1);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
- }
- }
- if (__pyx_t_1) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4247, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4247, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (!__pyx_t_12) {
+ goto __pyx_L16_next_or;
} else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4247, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_native, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4247, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (__pyx_t_3) {
-
- /* "netCDF4/_netCDF4.pyx":4244
- * # variable.
- * if self.endian() == 'native':
- * if is_native_little and data.dtype.byteorder == '>': # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '<':
- */
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (__pyx_t_12) {
- } else {
- __pyx_t_3 = __pyx_t_12;
- goto __pyx_L16_bool_binop_done;
- }
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__15, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_3 = __pyx_t_12;
- __pyx_L16_bool_binop_done:;
- if (__pyx_t_3) {
-
- /* "netCDF4/_netCDF4.pyx":4245
- * if self.endian() == 'native':
- * if is_native_little and data.dtype.byteorder == '>':
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if is_native_big and data.dtype.byteorder == '<':
- * data.byteswap(True)
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
- /* "netCDF4/_netCDF4.pyx":4244
- * # variable.
- * if self.endian() == 'native':
- * if is_native_little and data.dtype.byteorder == '>': # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '<':
- */
- }
-
- /* "netCDF4/_netCDF4.pyx":4246
- * if is_native_little and data.dtype.byteorder == '>':
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '<': # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if self.endian() == 'big':
- */
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4246; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4246; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (__pyx_t_12) {
- } else {
- __pyx_t_3 = __pyx_t_12;
- goto __pyx_L19_bool_binop_done;
- }
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4246; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4246; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__14, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4246; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__15, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4247, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (!__pyx_t_12) {
+ } else {
__pyx_t_3 = __pyx_t_12;
- __pyx_L19_bool_binop_done:;
- if (__pyx_t_3) {
-
- /* "netCDF4/_netCDF4.pyx":4247
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '<':
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if self.endian() == 'big':
- * if is_native_big and data.dtype.byteorder not in ['=','|']:
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4247; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4247; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
- /* "netCDF4/_netCDF4.pyx":4246
- * if is_native_little and data.dtype.byteorder == '>':
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '<': # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if self.endian() == 'big':
- */
- }
-
- /* "netCDF4/_netCDF4.pyx":4243
- * # make sure byte-order of data matches byte-order of netcdf
- * # variable.
- * if self.endian() == 'native': # <<<<<<<<<<<<<<
- * if is_native_little and data.dtype.byteorder == '>':
- * data.byteswap(True)
- */
+ goto __pyx_L15_bool_binop_done;
}
+ __pyx_L16_next_or:;
/* "netCDF4/_netCDF4.pyx":4248
- * if is_native_big and data.dtype.byteorder == '<':
- * data.byteswap(True)
- * if self.endian() == 'big': # <<<<<<<<<<<<<<
- * if is_native_big and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True)
+ * # issue #554, pull request #555)
+ * if (is_native_little and data.dtype.byteorder == '>') or\
+ * (is_native_big and data.dtype.byteorder == '<'): # <<<<<<<<<<<<<<
+ * data = data.byteswap() # don't do in-place, make a copy
+ * # strides all 1 or scalar variable, use put_vara (faster)
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4248; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4248, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_1)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_1);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
- }
- }
- if (__pyx_t_1) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4248; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4248, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (__pyx_t_12) {
} else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4248; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_t_12;
+ goto __pyx_L15_bool_binop_done;
}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4248, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4248, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_big, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4248; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_kp_s__14, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4248, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (__pyx_t_3) {
-
- /* "netCDF4/_netCDF4.pyx":4249
- * data.byteswap(True)
- * if self.endian() == 'big':
- * if is_native_big and data.dtype.byteorder not in ['=','|']: # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if is_native_little and data.dtype.byteorder == '=':
- */
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4249; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4249; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (__pyx_t_12) {
- } else {
- __pyx_t_3 = __pyx_t_12;
- goto __pyx_L23_bool_binop_done;
- }
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4249; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4249; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__36, Py_NE)); if (unlikely(__pyx_t_13 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4249; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (__pyx_t_13) {
- } else {
- __pyx_t_12 = __pyx_t_13;
- goto __pyx_L25_bool_binop_done;
- }
- __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__37, Py_NE)); if (unlikely(__pyx_t_13 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4249; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_12 = __pyx_t_13;
- __pyx_L25_bool_binop_done:;
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_13 = (__pyx_t_12 != 0);
- __pyx_t_3 = __pyx_t_13;
- __pyx_L23_bool_binop_done:;
- if (__pyx_t_3) {
-
- /* "netCDF4/_netCDF4.pyx":4250
- * if self.endian() == 'big':
- * if is_native_big and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if is_native_little and data.dtype.byteorder == '=':
- * data.byteswap(True)
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4250; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__75, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4250; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
- /* "netCDF4/_netCDF4.pyx":4249
- * data.byteswap(True)
- * if self.endian() == 'big':
- * if is_native_big and data.dtype.byteorder not in ['=','|']: # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if is_native_little and data.dtype.byteorder == '=':
- */
- }
-
- /* "netCDF4/_netCDF4.pyx":4251
- * if is_native_big and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True)
- * if is_native_little and data.dtype.byteorder == '=': # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if self.endian() == 'little':
- */
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_13 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (__pyx_t_13) {
- } else {
- __pyx_t_3 = __pyx_t_13;
- goto __pyx_L28_bool_binop_done;
- }
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_13 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__36, Py_EQ)); if (unlikely(__pyx_t_13 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_3 = __pyx_t_13;
- __pyx_L28_bool_binop_done:;
- if (__pyx_t_3) {
-
- /* "netCDF4/_netCDF4.pyx":4252
- * data.byteswap(True)
- * if is_native_little and data.dtype.byteorder == '=':
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if self.endian() == 'little':
- * if is_native_little and data.dtype.byteorder not in ['=','|']:
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__76, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
- /* "netCDF4/_netCDF4.pyx":4251
- * if is_native_big and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True)
- * if is_native_little and data.dtype.byteorder == '=': # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if self.endian() == 'little':
- */
- }
-
- /* "netCDF4/_netCDF4.pyx":4248
- * if is_native_big and data.dtype.byteorder == '<':
- * data.byteswap(True)
- * if self.endian() == 'big': # <<<<<<<<<<<<<<
- * if is_native_big and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True)
- */
- }
+ __pyx_t_3 = __pyx_t_12;
+ __pyx_L15_bool_binop_done:;
- /* "netCDF4/_netCDF4.pyx":4253
- * if is_native_little and data.dtype.byteorder == '=':
- * data.byteswap(True)
- * if self.endian() == 'little': # <<<<<<<<<<<<<<
- * if is_native_little and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":4247
+ * # endian byte order (this is what netcdf-c expects -
+ * # issue #554, pull request #555)
+ * if (is_native_little and data.dtype.byteorder == '>') or\ # <<<<<<<<<<<<<<
+ * (is_native_big and data.dtype.byteorder == '<'):
+ * data = data.byteswap() # don't do in-place, make a copy
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_1 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
- __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
- if (likely(__pyx_t_1)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
- __Pyx_INCREF(__pyx_t_1);
- __Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_5, function);
- }
- }
- if (__pyx_t_1) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- } else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- }
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_little, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4254
- * data.byteswap(True)
- * if self.endian() == 'little':
- * if is_native_little and data.dtype.byteorder not in ['=','|']: # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '=':
+ /* "netCDF4/_netCDF4.pyx":4249
+ * if (is_native_little and data.dtype.byteorder == '>') or\
+ * (is_native_big and data.dtype.byteorder == '<'):
+ * data = data.byteswap() # don't do in-place, make a copy # <<<<<<<<<<<<<<
+ * # strides all 1 or scalar variable, use put_vara (faster)
+ * if sum(stride) == ndims or ndims == 0:
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_13 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (__pyx_t_13) {
- } else {
- __pyx_t_3 = __pyx_t_13;
- goto __pyx_L32_bool_binop_done;
- }
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__36, Py_NE)); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (__pyx_t_12) {
- } else {
- __pyx_t_13 = __pyx_t_12;
- goto __pyx_L34_bool_binop_done;
- }
- __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__37, Py_NE)); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_13 = __pyx_t_12;
- __pyx_L34_bool_binop_done:;
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_12 = (__pyx_t_13 != 0);
- __pyx_t_3 = __pyx_t_12;
- __pyx_L32_bool_binop_done:;
- if (__pyx_t_3) {
-
- /* "netCDF4/_netCDF4.pyx":4255
- * if self.endian() == 'little':
- * if is_native_little and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if is_native_big and data.dtype.byteorder == '=':
- * data.byteswap(True)
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4255; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__77, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4255; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
- /* "netCDF4/_netCDF4.pyx":4254
- * data.byteswap(True)
- * if self.endian() == 'little':
- * if is_native_little and data.dtype.byteorder not in ['=','|']: # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '=':
- */
+ __pyx_t_1 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_1)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_1);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
}
-
- /* "netCDF4/_netCDF4.pyx":4256
- * if is_native_little and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '=': # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * # strides all 1 or scalar variable, use put_vara (faster)
- */
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (__pyx_t_12) {
+ if (__pyx_t_1) {
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4249, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_3 = __pyx_t_12;
- goto __pyx_L37_bool_binop_done;
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4249, __pyx_L1_error)
}
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_5, __pyx_kp_s__36, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_3 = __pyx_t_12;
- __pyx_L37_bool_binop_done:;
- if (__pyx_t_3) {
-
- /* "netCDF4/_netCDF4.pyx":4257
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '=':
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * # strides all 1 or scalar variable, use put_vara (faster)
- * if sum(stride) == ndims or ndims == 0:
- */
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_byteswap); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
-
- /* "netCDF4/_netCDF4.pyx":4256
- * if is_native_little and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '=': # <<<<<<<<<<<<<<
- * data.byteswap(True)
- * # strides all 1 or scalar variable, use put_vara (faster)
- */
- }
+ if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4249, __pyx_L1_error)
+ __Pyx_DECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_4));
+ __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4253
- * if is_native_little and data.dtype.byteorder == '=':
- * data.byteswap(True)
- * if self.endian() == 'little': # <<<<<<<<<<<<<<
- * if is_native_little and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":4247
+ * # endian byte order (this is what netcdf-c expects -
+ * # issue #554, pull request #555)
+ * if (is_native_little and data.dtype.byteorder == '>') or\ # <<<<<<<<<<<<<<
+ * (is_native_big and data.dtype.byteorder == '<'):
+ * data = data.byteswap() # don't do in-place, make a copy
*/
}
- /* "netCDF4/_netCDF4.pyx":4259
- * data.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":4251
+ * data = data.byteswap() # don't do in-place, make a copy
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, data.data)
*/
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_stride);
__Pyx_GIVEREF(__pyx_v_stride);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_stride);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4251, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4251, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (!__pyx_t_12) {
} else {
__pyx_t_3 = __pyx_t_12;
- goto __pyx_L40_bool_binop_done;
+ goto __pyx_L20_bool_binop_done;
}
__pyx_t_12 = ((__pyx_v_ndims == 0) != 0);
__pyx_t_3 = __pyx_t_12;
- __pyx_L40_bool_binop_done:;
+ __pyx_L20_bool_binop_done:;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4260
+ /* "netCDF4/_netCDF4.pyx":4252
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* ierr = nc_put_vara(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -45497,17 +44787,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_ierr = nc_put_vara(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_data->data);
- /* "netCDF4/_netCDF4.pyx":4259
- * data.byteswap(True)
+ /* "netCDF4/_netCDF4.pyx":4251
+ * data = data.byteswap() # don't do in-place, make a copy
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, data.data)
*/
- goto __pyx_L39;
+ goto __pyx_L19;
}
- /* "netCDF4/_netCDF4.pyx":4263
+ /* "netCDF4/_netCDF4.pyx":4255
* startp, countp, data.data)
* else:
* ierr = nc_put_vars(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -45516,7 +44806,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
/*else*/ {
- /* "netCDF4/_netCDF4.pyx":4264
+ /* "netCDF4/_netCDF4.pyx":4256
* else:
* ierr = nc_put_vars(self._grpid, self._varid,
* startp, countp, stridep, data.data) # <<<<<<<<<<<<<<
@@ -45525,9 +44815,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_ierr = nc_put_vars(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_stridep, __pyx_v_data->data);
}
- __pyx_L39:;
+ __pyx_L19:;
- /* "netCDF4/_netCDF4.pyx":4265
+ /* "netCDF4/_netCDF4.pyx":4257
* ierr = nc_put_vars(self._grpid, self._varid,
* startp, countp, stridep, data.data)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -45537,30 +44827,30 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4266
+ /* "netCDF4/_netCDF4.pyx":4258
* startp, countp, stridep, data.data)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
* elif self._isvlen:
* if data.dtype.char !='O':
*/
- __pyx_t_14 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_14, 0, strlen(__pyx_t_14), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4266; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = ((char *)nc_strerror(__pyx_v_ierr));
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4258, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4266; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4258, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4266; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4258, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4266; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4258, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4265
+ /* "netCDF4/_netCDF4.pyx":4257
* ierr = nc_put_vars(self._grpid, self._varid,
* startp, countp, stridep, data.data)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -45569,7 +44859,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4235
+ /* "netCDF4/_netCDF4.pyx":4238
* # reverse data along axes with negative strides.
* data = data[sl].copy() # make sure a copy is made.
* if self._isprimitive or self._iscompound or self._isenum: # <<<<<<<<<<<<<<
@@ -45579,46 +44869,46 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":4267
+ /* "netCDF4/_netCDF4.pyx":4259
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* elif self._isvlen: # <<<<<<<<<<<<<<
* if data.dtype.char !='O':
* raise TypeError('data to put in string variable must be an object array containing Python strings')
*/
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4267; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4259, __pyx_L1_error)
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4268
+ /* "netCDF4/_netCDF4.pyx":4260
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* elif self._isvlen:
* if data.dtype.char !='O': # <<<<<<<<<<<<<<
* raise TypeError('data to put in string variable must be an object array containing Python strings')
* # flatten data array.
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4268; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4260, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_char); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4268; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_char); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4260, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_O, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4268; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_O, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4260, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4269
+ /* "netCDF4/_netCDF4.pyx":4261
* elif self._isvlen:
* if data.dtype.char !='O':
* raise TypeError('data to put in string variable must be an object array containing Python strings') # <<<<<<<<<<<<<<
* # flatten data array.
* data = data.flatten()
*/
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4269; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4261, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4269; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4261, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4268
+ /* "netCDF4/_netCDF4.pyx":4260
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* elif self._isvlen:
* if data.dtype.char !='O': # <<<<<<<<<<<<<<
@@ -45627,14 +44917,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4271
+ /* "netCDF4/_netCDF4.pyx":4263
* raise TypeError('data to put in string variable must be an object array containing Python strings')
* # flatten data array.
* data = data.flatten() # <<<<<<<<<<<<<<
* if self.dtype == str:
* # convert all elements from strings to bytes
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_flatten); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4271; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_flatten); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4263, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -45647,84 +44937,84 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
}
}
if (__pyx_t_5) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4271; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4263, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4271; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4263, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4271; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4263, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_4));
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4272
+ /* "netCDF4/_netCDF4.pyx":4264
* # flatten data array.
* data = data.flatten()
* if self.dtype == str: # <<<<<<<<<<<<<<
* # convert all elements from strings to bytes
* for n in range(data.shape[0]):
*/
- __pyx_t_4 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4272; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4272; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4264, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4264, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4274
+ /* "netCDF4/_netCDF4.pyx":4266
* if self.dtype == str:
* # convert all elements from strings to bytes
* for n in range(data.shape[0]): # <<<<<<<<<<<<<<
* data[n] = _strencode(data[n])
* # vlen string (NC_STRING)
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_shape); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_2 = 0;
- __pyx_t_15 = NULL;
+ __pyx_t_14 = NULL;
} else {
- __pyx_t_2 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_15 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 4266, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
- if (likely(!__pyx_t_15)) {
+ if (likely(!__pyx_t_14)) {
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_2); __Pyx_INCREF(__pyx_t_1); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_2); __Pyx_INCREF(__pyx_t_1); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 4266, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_2); __Pyx_INCREF(__pyx_t_1); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_2); __Pyx_INCREF(__pyx_t_1); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 4266, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4266, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
} else {
- __pyx_t_1 = __pyx_t_15(__pyx_t_4);
+ __pyx_t_1 = __pyx_t_14(__pyx_t_4);
if (unlikely(!__pyx_t_1)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4266, __pyx_L1_error)
}
break;
}
@@ -45733,22 +45023,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4275
+ /* "netCDF4/_netCDF4.pyx":4267
* # convert all elements from strings to bytes
* for n in range(data.shape[0]):
* data[n] = _strencode(data[n]) # <<<<<<<<<<<<<<
* # vlen string (NC_STRING)
* # loop over elements of object array, put data buffer for
*/
- __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_data), __pyx_v_n); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4275; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(((PyObject *)__pyx_v_data), __pyx_v_n); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_data), __pyx_v_n, __pyx_t_5) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4275; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_data), __pyx_v_n, __pyx_t_5) < 0)) __PYX_ERR(0, 4267, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- /* "netCDF4/_netCDF4.pyx":4274
+ /* "netCDF4/_netCDF4.pyx":4266
* if self.dtype == str:
* # convert all elements from strings to bytes
* for n in range(data.shape[0]): # <<<<<<<<<<<<<<
@@ -45758,7 +45048,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4280
+ /* "netCDF4/_netCDF4.pyx":4272
* # each element in struct.
* # allocate struct array to hold vlen data.
* strdata = <char **>malloc(sizeof(char *)*totelem) # <<<<<<<<<<<<<<
@@ -45767,63 +45057,63 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_strdata = ((char **)malloc(((sizeof(char *)) * __pyx_v_totelem)));
- /* "netCDF4/_netCDF4.pyx":4281
+ /* "netCDF4/_netCDF4.pyx":4273
* # allocate struct array to hold vlen data.
* strdata = <char **>malloc(sizeof(char *)*totelem)
* for i from 0<=i<totelem: # <<<<<<<<<<<<<<
* strdata[i] = data[i]
* # strides all 1 or scalar variable, use put_vara (faster)
*/
- __pyx_t_16 = __pyx_v_totelem;
- for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_16; __pyx_v_i++) {
+ __pyx_t_15 = __pyx_v_totelem;
+ for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_15; __pyx_v_i++) {
- /* "netCDF4/_netCDF4.pyx":4282
+ /* "netCDF4/_netCDF4.pyx":4274
* strdata = <char **>malloc(sizeof(char *)*totelem)
* for i from 0<=i<totelem:
* strdata[i] = data[i] # <<<<<<<<<<<<<<
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0:
*/
- __pyx_t_4 = __Pyx_GetItemInt(((PyObject *)__pyx_v_data), __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4282; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(((PyObject *)__pyx_v_data), __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_14 = __Pyx_PyObject_AsString(__pyx_t_4); if (unlikely((!__pyx_t_14) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4282; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- (__pyx_v_strdata[__pyx_v_i]) = __pyx_t_14;
+ __pyx_t_13 = __Pyx_PyObject_AsString(__pyx_t_4); if (unlikely((!__pyx_t_13) && PyErr_Occurred())) __PYX_ERR(0, 4274, __pyx_L1_error)
+ (__pyx_v_strdata[__pyx_v_i]) = __pyx_t_13;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
- /* "netCDF4/_netCDF4.pyx":4284
+ /* "netCDF4/_netCDF4.pyx":4276
* strdata[i] = data[i]
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, strdata)
*/
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4284; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_stride);
__Pyx_GIVEREF(__pyx_v_stride);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_stride);
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4284; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4284; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4284; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_5, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4276, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4284; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4276, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (!__pyx_t_12) {
} else {
__pyx_t_3 = __pyx_t_12;
- goto __pyx_L50_bool_binop_done;
+ goto __pyx_L30_bool_binop_done;
}
__pyx_t_12 = ((__pyx_v_ndims == 0) != 0);
__pyx_t_3 = __pyx_t_12;
- __pyx_L50_bool_binop_done:;
+ __pyx_L30_bool_binop_done:;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4285
+ /* "netCDF4/_netCDF4.pyx":4277
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* ierr = nc_put_vara(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -45832,17 +45122,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_ierr = nc_put_vara(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_strdata);
- /* "netCDF4/_netCDF4.pyx":4284
+ /* "netCDF4/_netCDF4.pyx":4276
* strdata[i] = data[i]
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, strdata)
*/
- goto __pyx_L49;
+ goto __pyx_L29;
}
- /* "netCDF4/_netCDF4.pyx":4288
+ /* "netCDF4/_netCDF4.pyx":4280
* startp, countp, strdata)
* else:
* raise IndexError('strides must all be 1 for string variables') # <<<<<<<<<<<<<<
@@ -45850,15 +45140,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
* # startp, countp, stridep, strdata)
*/
/*else*/ {
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4288; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4280, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4288; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4280, __pyx_L1_error)
}
- __pyx_L49:;
+ __pyx_L29:;
- /* "netCDF4/_netCDF4.pyx":4291
+ /* "netCDF4/_netCDF4.pyx":4283
* #ierr = nc_put_vars(self._grpid, self._varid,
* # startp, countp, stridep, strdata)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -45868,30 +45158,30 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4292
+ /* "netCDF4/_netCDF4.pyx":4284
* # startp, countp, stridep, strdata)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
* free(strdata)
* else:
*/
- __pyx_t_14 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_14, 0, strlen(__pyx_t_14), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = ((char *)nc_strerror(__pyx_v_ierr));
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4284, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4284, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4284, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4284, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4291
+ /* "netCDF4/_netCDF4.pyx":4283
* #ierr = nc_put_vars(self._grpid, self._varid,
* # startp, countp, stridep, strdata)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -45900,7 +45190,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4293
+ /* "netCDF4/_netCDF4.pyx":4285
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* free(strdata) # <<<<<<<<<<<<<<
@@ -45909,17 +45199,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
free(__pyx_v_strdata);
- /* "netCDF4/_netCDF4.pyx":4272
+ /* "netCDF4/_netCDF4.pyx":4264
* # flatten data array.
* data = data.flatten()
* if self.dtype == str: # <<<<<<<<<<<<<<
* # convert all elements from strings to bytes
* for n in range(data.shape[0]):
*/
- goto __pyx_L44;
+ goto __pyx_L24;
}
- /* "netCDF4/_netCDF4.pyx":4298
+ /* "netCDF4/_netCDF4.pyx":4290
* # loop over elements of object array, put data buffer for
* # each element in struct.
* databuff = data.data # <<<<<<<<<<<<<<
@@ -45927,10 +45217,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
* vldata = <nc_vlen_t *>malloc(<size_t>totelem*sizeof(nc_vlen_t))
*/
/*else*/ {
- __pyx_t_14 = __pyx_v_data->data;
- __pyx_v_databuff = __pyx_t_14;
+ __pyx_t_13 = __pyx_v_data->data;
+ __pyx_v_databuff = __pyx_t_13;
- /* "netCDF4/_netCDF4.pyx":4300
+ /* "netCDF4/_netCDF4.pyx":4292
* databuff = data.data
* # allocate struct array to hold vlen data.
* vldata = <nc_vlen_t *>malloc(<size_t>totelem*sizeof(nc_vlen_t)) # <<<<<<<<<<<<<<
@@ -45939,17 +45229,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_vldata = ((nc_vlen_t *)malloc((((size_t)__pyx_v_totelem) * (sizeof(nc_vlen_t)))));
- /* "netCDF4/_netCDF4.pyx":4301
+ /* "netCDF4/_netCDF4.pyx":4293
* # allocate struct array to hold vlen data.
* vldata = <nc_vlen_t *>malloc(<size_t>totelem*sizeof(nc_vlen_t))
* for i from 0<=i<totelem: # <<<<<<<<<<<<<<
* elptr = (<void**>databuff)[0]
* dataarr = <ndarray>elptr
*/
- __pyx_t_16 = __pyx_v_totelem;
- for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_16; __pyx_v_i++) {
+ __pyx_t_15 = __pyx_v_totelem;
+ for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_15; __pyx_v_i++) {
- /* "netCDF4/_netCDF4.pyx":4302
+ /* "netCDF4/_netCDF4.pyx":4294
* vldata = <nc_vlen_t *>malloc(<size_t>totelem*sizeof(nc_vlen_t))
* for i from 0<=i<totelem:
* elptr = (<void**>databuff)[0] # <<<<<<<<<<<<<<
@@ -45958,7 +45248,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_elptr = (((void **)__pyx_v_databuff)[0]);
- /* "netCDF4/_netCDF4.pyx":4303
+ /* "netCDF4/_netCDF4.pyx":4295
* for i from 0<=i<totelem:
* elptr = (<void**>databuff)[0]
* dataarr = <ndarray>elptr # <<<<<<<<<<<<<<
@@ -45970,37 +45260,37 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__Pyx_XDECREF_SET(__pyx_v_dataarr, ((PyArrayObject *)__pyx_t_1));
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4304
+ /* "netCDF4/_netCDF4.pyx":4296
* elptr = (<void**>databuff)[0]
* dataarr = <ndarray>elptr
* if self.dtype != dataarr.dtype.str[1:]: # <<<<<<<<<<<<<<
* #dataarr = dataarr.astype(self.dtype) # cast data, if necessary.
* # casting doesn't work ?? just raise TypeError
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dataarr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dataarr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4296, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_str); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_str); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4296, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_4, 1, 0, NULL, NULL, &__pyx_slice__81, 1, 0, 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_4, 1, 0, NULL, NULL, &__pyx_slice__73, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4296, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyObject_RichCompare(__pyx_v_self->dtype, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_self->dtype, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4296, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 4296, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4307
+ /* "netCDF4/_netCDF4.pyx":4299
* #dataarr = dataarr.astype(self.dtype) # cast data, if necessary.
* # casting doesn't work ?? just raise TypeError
* raise TypeError("wrong data type in object array: should be %s, got %s" % (self.dtype,dataarr.dtype)) # <<<<<<<<<<<<<<
* vldata[i].len = PyArray_SIZE(dataarr)
* vldata[i].p = dataarr.data
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dataarr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dataarr), __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4299, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4299, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
@@ -46008,22 +45298,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_wrong_data_type_in_object_array, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_wrong_data_type_in_object_array, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4299, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4299, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4299, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4299, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4304
+ /* "netCDF4/_netCDF4.pyx":4296
* elptr = (<void**>databuff)[0]
* dataarr = <ndarray>elptr
* if self.dtype != dataarr.dtype.str[1:]: # <<<<<<<<<<<<<<
@@ -46032,7 +45322,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4308
+ /* "netCDF4/_netCDF4.pyx":4300
* # casting doesn't work ?? just raise TypeError
* raise TypeError("wrong data type in object array: should be %s, got %s" % (self.dtype,dataarr.dtype))
* vldata[i].len = PyArray_SIZE(dataarr) # <<<<<<<<<<<<<<
@@ -46041,17 +45331,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
(__pyx_v_vldata[__pyx_v_i]).len = PyArray_SIZE(__pyx_v_dataarr);
- /* "netCDF4/_netCDF4.pyx":4309
+ /* "netCDF4/_netCDF4.pyx":4301
* raise TypeError("wrong data type in object array: should be %s, got %s" % (self.dtype,dataarr.dtype))
* vldata[i].len = PyArray_SIZE(dataarr)
* vldata[i].p = dataarr.data # <<<<<<<<<<<<<<
* databuff = databuff + data.strides[0]
* # strides all 1 or scalar variable, use put_vara (faster)
*/
- __pyx_t_14 = __pyx_v_dataarr->data;
- (__pyx_v_vldata[__pyx_v_i]).p = __pyx_t_14;
+ __pyx_t_13 = __pyx_v_dataarr->data;
+ (__pyx_v_vldata[__pyx_v_i]).p = __pyx_t_13;
- /* "netCDF4/_netCDF4.pyx":4310
+ /* "netCDF4/_netCDF4.pyx":4302
* vldata[i].len = PyArray_SIZE(dataarr)
* vldata[i].p = dataarr.data
* databuff = databuff + data.strides[0] # <<<<<<<<<<<<<<
@@ -46061,39 +45351,39 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__pyx_v_databuff = (__pyx_v_databuff + (__pyx_v_data->strides[0]));
}
- /* "netCDF4/_netCDF4.pyx":4312
+ /* "netCDF4/_netCDF4.pyx":4304
* databuff = databuff + data.strides[0]
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, vldata)
*/
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4304, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_stride);
__Pyx_GIVEREF(__pyx_v_stride);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_stride);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4304, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4304, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_RichCompare(__pyx_t_1, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4304, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4304, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (!__pyx_t_12) {
} else {
__pyx_t_3 = __pyx_t_12;
- goto __pyx_L57_bool_binop_done;
+ goto __pyx_L37_bool_binop_done;
}
__pyx_t_12 = ((__pyx_v_ndims == 0) != 0);
__pyx_t_3 = __pyx_t_12;
- __pyx_L57_bool_binop_done:;
+ __pyx_L37_bool_binop_done:;
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4313
+ /* "netCDF4/_netCDF4.pyx":4305
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* ierr = nc_put_vara(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -46102,17 +45392,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
__pyx_v_ierr = nc_put_vara(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_vldata);
- /* "netCDF4/_netCDF4.pyx":4312
+ /* "netCDF4/_netCDF4.pyx":4304
* databuff = databuff + data.strides[0]
* # strides all 1 or scalar variable, use put_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* ierr = nc_put_vara(self._grpid, self._varid,
* startp, countp, vldata)
*/
- goto __pyx_L56;
+ goto __pyx_L36;
}
- /* "netCDF4/_netCDF4.pyx":4316
+ /* "netCDF4/_netCDF4.pyx":4308
* startp, countp, vldata)
* else:
* raise IndexError('strides must all be 1 for vlen variables') # <<<<<<<<<<<<<<
@@ -46120,15 +45410,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
* # startp, countp, stridep, vldata)
*/
/*else*/ {
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4316; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4308, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4316; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4308, __pyx_L1_error)
}
- __pyx_L56:;
+ __pyx_L36:;
- /* "netCDF4/_netCDF4.pyx":4319
+ /* "netCDF4/_netCDF4.pyx":4311
* #ierr = nc_put_vars(self._grpid, self._varid,
* # startp, countp, stridep, vldata)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -46138,30 +45428,30 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
__pyx_t_3 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_3) {
- /* "netCDF4/_netCDF4.pyx":4320
+ /* "netCDF4/_netCDF4.pyx":4312
* # startp, countp, stridep, vldata)
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
* # free the pointer array.
* free(vldata)
*/
- __pyx_t_14 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_5 = __Pyx_decode_c_string(__pyx_t_14, 0, strlen(__pyx_t_14), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4320; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = ((char *)nc_strerror(__pyx_v_ierr));
+ __pyx_t_5 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4312, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4320; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4312, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4320; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4312, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4320; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4312, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4319
+ /* "netCDF4/_netCDF4.pyx":4311
* #ierr = nc_put_vars(self._grpid, self._varid,
* # startp, countp, stridep, vldata)
* if ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -46170,7 +45460,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4322
+ /* "netCDF4/_netCDF4.pyx":4314
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* # free the pointer array.
* free(vldata) # <<<<<<<<<<<<<<
@@ -46179,9 +45469,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
free(__pyx_v_vldata);
}
- __pyx_L44:;
+ __pyx_L24:;
- /* "netCDF4/_netCDF4.pyx":4267
+ /* "netCDF4/_netCDF4.pyx":4259
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* elif self._isvlen: # <<<<<<<<<<<<<<
@@ -46191,7 +45481,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
}
__pyx_L9:;
- /* "netCDF4/_netCDF4.pyx":4323
+ /* "netCDF4/_netCDF4.pyx":4315
* # free the pointer array.
* free(vldata)
* free(startp) # <<<<<<<<<<<<<<
@@ -46200,7 +45490,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
free(__pyx_v_startp);
- /* "netCDF4/_netCDF4.pyx":4324
+ /* "netCDF4/_netCDF4.pyx":4316
* free(vldata)
* free(startp)
* free(countp) # <<<<<<<<<<<<<<
@@ -46209,7 +45499,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
free(__pyx_v_countp);
- /* "netCDF4/_netCDF4.pyx":4325
+ /* "netCDF4/_netCDF4.pyx":4317
* free(startp)
* free(countp)
* free(stridep) # <<<<<<<<<<<<<<
@@ -46218,7 +45508,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
*/
free(__pyx_v_stridep);
- /* "netCDF4/_netCDF4.pyx":4187
+ /* "netCDF4/_netCDF4.pyx":4190
*
*
* def _put(self,ndarray data,start,count,stride): # <<<<<<<<<<<<<<
@@ -46246,7 +45536,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_64_put(struct __pyx_obj_7
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":4327
+/* "netCDF4/_netCDF4.pyx":4319
* free(stridep)
*
* def _get(self,start,count,stride): # <<<<<<<<<<<<<<
@@ -46261,9 +45551,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_67_get(PyObject *__pyx_v_
PyObject *__pyx_v_start = 0;
PyObject *__pyx_v_count = 0;
PyObject *__pyx_v_stride = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get (wrapper)", 0);
@@ -46288,16 +45575,16 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_67_get(PyObject *__pyx_v_
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_count)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("_get", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4327; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_get", 1, 3, 3, 1); __PYX_ERR(0, 4319, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_stride)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("_get", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4327; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_get", 1, 3, 3, 2); __PYX_ERR(0, 4319, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_get") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4327; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_get") < 0)) __PYX_ERR(0, 4319, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
@@ -46312,7 +45599,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_8Variable_67_get(PyObject *__pyx_v_
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("_get", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4327; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("_get", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4319, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.Variable._get", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -46361,12 +45648,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
char *__pyx_t_13;
long __pyx_t_14;
PyObject *__pyx_t_15 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_get", 0);
- /* "netCDF4/_netCDF4.pyx":4340
+ /* "netCDF4/_netCDF4.pyx":4332
* # and not a slice so the resulting array
* # should be 'squeezed' to remove the singleton dimension.
* shapeout = () # <<<<<<<<<<<<<<
@@ -46376,7 +45660,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__Pyx_INCREF(__pyx_empty_tuple);
__pyx_v_shapeout = __pyx_empty_tuple;
- /* "netCDF4/_netCDF4.pyx":4341
+ /* "netCDF4/_netCDF4.pyx":4333
* # should be 'squeezed' to remove the singleton dimension.
* shapeout = ()
* squeeze_out = False # <<<<<<<<<<<<<<
@@ -46385,7 +45669,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
__pyx_v_squeeze_out = 0;
- /* "netCDF4/_netCDF4.pyx":4342
+ /* "netCDF4/_netCDF4.pyx":4334
* shapeout = ()
* squeeze_out = False
* for lendim in count: # <<<<<<<<<<<<<<
@@ -46396,26 +45680,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_1 = __pyx_v_count; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
__pyx_t_3 = NULL;
} else {
- __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_count); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4334, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4334, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_3)) {
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 4334, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4334, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(0, 4334, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4334, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -46425,7 +45709,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4334, __pyx_L1_error)
}
break;
}
@@ -46434,32 +45718,32 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__Pyx_XDECREF_SET(__pyx_v_lendim, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4343
+ /* "netCDF4/_netCDF4.pyx":4335
* squeeze_out = False
* for lendim in count:
* if lendim == -1: # <<<<<<<<<<<<<<
* shapeout = shapeout + (1,)
* squeeze_out = True
*/
- __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_v_lendim, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4343; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_v_lendim, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4335, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4343; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4335, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4344
+ /* "netCDF4/_netCDF4.pyx":4336
* for lendim in count:
* if lendim == -1:
* shapeout = shapeout + (1,) # <<<<<<<<<<<<<<
* squeeze_out = True
* else:
*/
- __pyx_t_4 = PyNumber_Add(__pyx_v_shapeout, __pyx_tuple__83); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Add(__pyx_v_shapeout, __pyx_tuple__75); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4336, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF_SET(__pyx_v_shapeout, __pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4345
+ /* "netCDF4/_netCDF4.pyx":4337
* if lendim == -1:
* shapeout = shapeout + (1,)
* squeeze_out = True # <<<<<<<<<<<<<<
@@ -46468,7 +45752,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
__pyx_v_squeeze_out = 1;
- /* "netCDF4/_netCDF4.pyx":4343
+ /* "netCDF4/_netCDF4.pyx":4335
* squeeze_out = False
* for lendim in count:
* if lendim == -1: # <<<<<<<<<<<<<<
@@ -46478,7 +45762,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
goto __pyx_L5;
}
- /* "netCDF4/_netCDF4.pyx":4347
+ /* "netCDF4/_netCDF4.pyx":4339
* squeeze_out = True
* else:
* shapeout = shapeout + (lendim,) # <<<<<<<<<<<<<<
@@ -46486,12 +45770,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* ndims = len(self.dimensions)
*/
/*else*/ {
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4347; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4339, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_lendim);
__Pyx_GIVEREF(__pyx_v_lendim);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_lendim);
- __pyx_t_6 = PyNumber_Add(__pyx_v_shapeout, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4347; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Add(__pyx_v_shapeout, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4339, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF_SET(__pyx_v_shapeout, __pyx_t_6);
@@ -46499,7 +45783,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
__pyx_L5:;
- /* "netCDF4/_netCDF4.pyx":4342
+ /* "netCDF4/_netCDF4.pyx":4334
* shapeout = ()
* squeeze_out = False
* for lendim in count: # <<<<<<<<<<<<<<
@@ -46509,20 +45793,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4349
+ /* "netCDF4/_netCDF4.pyx":4341
* shapeout = shapeout + (lendim,)
* # rank of variable.
* ndims = len(self.dimensions) # <<<<<<<<<<<<<<
* # fill up startp,countp,stridep.
* negstride = 0
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4349; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4341, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4349; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(0, 4341, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_ndims = __pyx_t_2;
- /* "netCDF4/_netCDF4.pyx":4351
+ /* "netCDF4/_netCDF4.pyx":4343
* ndims = len(self.dimensions)
* # fill up startp,countp,stridep.
* negstride = 0 # <<<<<<<<<<<<<<
@@ -46531,19 +45815,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
__pyx_v_negstride = 0;
- /* "netCDF4/_netCDF4.pyx":4352
+ /* "netCDF4/_netCDF4.pyx":4344
* # fill up startp,countp,stridep.
* negstride = 0
* sl = [] # <<<<<<<<<<<<<<
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4352; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4344, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_sl = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4353
+ /* "netCDF4/_netCDF4.pyx":4345
* negstride = 0
* sl = []
* startp = <size_t *>malloc(sizeof(size_t) * ndims) # <<<<<<<<<<<<<<
@@ -46552,7 +45836,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
__pyx_v_startp = ((size_t *)malloc(((sizeof(size_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":4354
+ /* "netCDF4/_netCDF4.pyx":4346
* sl = []
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims) # <<<<<<<<<<<<<<
@@ -46561,7 +45845,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
__pyx_v_countp = ((size_t *)malloc(((sizeof(size_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":4355
+ /* "netCDF4/_netCDF4.pyx":4347
* startp = <size_t *>malloc(sizeof(size_t) * ndims)
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
* stridep = <ptrdiff_t *>malloc(sizeof(ptrdiff_t) * ndims) # <<<<<<<<<<<<<<
@@ -46570,7 +45854,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
__pyx_v_stridep = ((ptrdiff_t *)malloc(((sizeof(ptrdiff_t)) * __pyx_v_ndims)));
- /* "netCDF4/_netCDF4.pyx":4356
+ /* "netCDF4/_netCDF4.pyx":4348
* countp = <size_t *>malloc(sizeof(size_t) * ndims)
* stridep = <ptrdiff_t *>malloc(sizeof(ptrdiff_t) * ndims)
* for n from 0 <= n < ndims: # <<<<<<<<<<<<<<
@@ -46580,50 +45864,50 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_7 = __pyx_v_ndims;
for (__pyx_v_n = 0; __pyx_v_n < __pyx_t_7; __pyx_v_n++) {
- /* "netCDF4/_netCDF4.pyx":4357
+ /* "netCDF4/_netCDF4.pyx":4349
* stridep = <ptrdiff_t *>malloc(sizeof(ptrdiff_t) * ndims)
* for n from 0 <= n < ndims:
* count[n] = abs(count[n]) # make -1 into +1 # <<<<<<<<<<<<<<
* countp[n] = count[n]
* # for neg strides, reverse order (then flip that axis after data read in)
*/
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_count, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4357; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_count, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4349, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyNumber_Absolute(__pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Absolute(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4349, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(__Pyx_SetItemInt(__pyx_v_count, __pyx_v_n, __pyx_t_6, long, 1, __Pyx_PyInt_From_long, 0, 1, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4357; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_SetItemInt(__pyx_v_count, __pyx_v_n, __pyx_t_6, long, 1, __Pyx_PyInt_From_long, 0, 1, 1) < 0)) __PYX_ERR(0, 4349, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":4358
+ /* "netCDF4/_netCDF4.pyx":4350
* for n from 0 <= n < ndims:
* count[n] = abs(count[n]) # make -1 into +1
* countp[n] = count[n] # <<<<<<<<<<<<<<
* # for neg strides, reverse order (then flip that axis after data read in)
* if stride[n] < 0:
*/
- __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_count, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4358; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_count, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4350, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4358; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4350, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
(__pyx_v_countp[__pyx_v_n]) = __pyx_t_8;
- /* "netCDF4/_netCDF4.pyx":4360
+ /* "netCDF4/_netCDF4.pyx":4352
* countp[n] = count[n]
* # for neg strides, reverse order (then flip that axis after data read in)
* if stride[n] < 0: # <<<<<<<<<<<<<<
* negstride = 1
* stridep[n] = -stride[n]
*/
- __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4360; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_6, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4360; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_6, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4352, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4360; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4352, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4361
+ /* "netCDF4/_netCDF4.pyx":4353
* # for neg strides, reverse order (then flip that axis after data read in)
* if stride[n] < 0:
* negstride = 1 # <<<<<<<<<<<<<<
@@ -46632,75 +45916,75 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
__pyx_v_negstride = 1;
- /* "netCDF4/_netCDF4.pyx":4362
+ /* "netCDF4/_netCDF4.pyx":4354
* if stride[n] < 0:
* negstride = 1
* stridep[n] = -stride[n] # <<<<<<<<<<<<<<
* startp[n] = start[n]+stride[n]*(count[n]-1)
* stride[n] = -stride[n]
*/
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4362; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4354, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4362; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Negative(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4354, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_9 = __Pyx_PyInt_As_ptrdiff_t(__pyx_t_6); if (unlikely((__pyx_t_9 == (ptrdiff_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4362; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_ptrdiff_t(__pyx_t_6); if (unlikely((__pyx_t_9 == (ptrdiff_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4354, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
(__pyx_v_stridep[__pyx_v_n]) = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":4363
+ /* "netCDF4/_netCDF4.pyx":4355
* negstride = 1
* stridep[n] = -stride[n]
* startp[n] = start[n]+stride[n]*(count[n]-1) # <<<<<<<<<<<<<<
* stride[n] = -stride[n]
* sl.append(slice(None, None, -1)) # this slice will reverse the data
*/
- __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_start, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4363; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_start, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4355, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4363; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4355, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_count, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4363; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_count, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4355, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_10 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_SubtractObjC(__pyx_t_4, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4355, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4355, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = PyNumber_Add(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyNumber_Add(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4355, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_10); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4363; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_10); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4355, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
(__pyx_v_startp[__pyx_v_n]) = __pyx_t_8;
- /* "netCDF4/_netCDF4.pyx":4364
+ /* "netCDF4/_netCDF4.pyx":4356
* stridep[n] = -stride[n]
* startp[n] = start[n]+stride[n]*(count[n]-1)
* stride[n] = -stride[n] # <<<<<<<<<<<<<<
* sl.append(slice(None, None, -1)) # this slice will reverse the data
* else:
*/
- __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4364; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4356, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_4 = PyNumber_Negative(__pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4364; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Negative(__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4356, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- if (unlikely(__Pyx_SetItemInt(__pyx_v_stride, __pyx_v_n, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 1, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4364; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_SetItemInt(__pyx_v_stride, __pyx_v_n, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 1, 1) < 0)) __PYX_ERR(0, 4356, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4365
+ /* "netCDF4/_netCDF4.pyx":4357
* startp[n] = start[n]+stride[n]*(count[n]-1)
* stride[n] = -stride[n]
* sl.append(slice(None, None, -1)) # this slice will reverse the data # <<<<<<<<<<<<<<
* else:
* startp[n] = start[n]
*/
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_sl, __pyx_slice__84); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_sl, __pyx_slice__76); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 4357, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4360
+ /* "netCDF4/_netCDF4.pyx":4352
* countp[n] = count[n]
* # for neg strides, reverse order (then flip that axis after data read in)
* if stride[n] < 0: # <<<<<<<<<<<<<<
@@ -46710,7 +45994,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
goto __pyx_L8;
}
- /* "netCDF4/_netCDF4.pyx":4367
+ /* "netCDF4/_netCDF4.pyx":4359
* sl.append(slice(None, None, -1)) # this slice will reverse the data
* else:
* startp[n] = start[n] # <<<<<<<<<<<<<<
@@ -46718,71 +46002,71 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* sl.append(slice(None,None, 1))
*/
/*else*/ {
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_start, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4367; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_start, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4359, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4367; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4359, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
(__pyx_v_startp[__pyx_v_n]) = __pyx_t_8;
- /* "netCDF4/_netCDF4.pyx":4368
+ /* "netCDF4/_netCDF4.pyx":4360
* else:
* startp[n] = start[n]
* stridep[n] = stride[n] # <<<<<<<<<<<<<<
* sl.append(slice(None,None, 1))
* if self._isprimitive or self._iscompound or self._isenum:
*/
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4368; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_stride, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4360, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_9 = __Pyx_PyInt_As_ptrdiff_t(__pyx_t_4); if (unlikely((__pyx_t_9 == (ptrdiff_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4368; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_ptrdiff_t(__pyx_t_4); if (unlikely((__pyx_t_9 == (ptrdiff_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4360, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
(__pyx_v_stridep[__pyx_v_n]) = __pyx_t_9;
- /* "netCDF4/_netCDF4.pyx":4369
+ /* "netCDF4/_netCDF4.pyx":4361
* startp[n] = start[n]
* stridep[n] = stride[n]
* sl.append(slice(None,None, 1)) # <<<<<<<<<<<<<<
* if self._isprimitive or self._iscompound or self._isenum:
* data = numpy.empty(shapeout, self.dtype)
*/
- __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_sl, __pyx_slice__85); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4369; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_sl, __pyx_slice__77); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 4361, __pyx_L1_error)
}
__pyx_L8:;
}
- /* "netCDF4/_netCDF4.pyx":4370
+ /* "netCDF4/_netCDF4.pyx":4362
* stridep[n] = stride[n]
* sl.append(slice(None,None, 1))
* if self._isprimitive or self._iscompound or self._isenum: # <<<<<<<<<<<<<<
* data = numpy.empty(shapeout, self.dtype)
* # strides all 1 or scalar variable, use get_vara (faster)
*/
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isprimitive); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4362, __pyx_L1_error)
if (!__pyx_t_12) {
} else {
__pyx_t_5 = __pyx_t_12;
goto __pyx_L10_bool_binop_done;
}
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_iscompound); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4362, __pyx_L1_error)
if (!__pyx_t_12) {
} else {
__pyx_t_5 = __pyx_t_12;
goto __pyx_L10_bool_binop_done;
}
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4370; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isenum); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4362, __pyx_L1_error)
__pyx_t_5 = __pyx_t_12;
__pyx_L10_bool_binop_done:;
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4371
+ /* "netCDF4/_netCDF4.pyx":4363
* sl.append(slice(None,None, 1))
* if self._isprimitive or self._iscompound or self._isenum:
* data = numpy.empty(shapeout, self.dtype) # <<<<<<<<<<<<<<
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0:
*/
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = NULL;
@@ -46797,7 +46081,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_2 = 1;
}
}
- __pyx_t_1 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__pyx_t_10) {
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_10); __pyx_t_10 = NULL;
@@ -46808,35 +46092,35 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__Pyx_INCREF(__pyx_v_self->dtype);
__Pyx_GIVEREF(__pyx_v_self->dtype);
PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_2, __pyx_v_self->dtype);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4371; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4363, __pyx_L1_error)
__pyx_v_data = ((PyArrayObject *)__pyx_t_4);
__pyx_t_4 = 0;
- /* "netCDF4/_netCDF4.pyx":4373
+ /* "netCDF4/_netCDF4.pyx":4365
* data = numpy.empty(shapeout, self.dtype)
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_get_vara(self._grpid, self._varid,
*/
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4373; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_stride);
__Pyx_GIVEREF(__pyx_v_stride);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_stride);
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4373; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4373; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_6, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4373; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_6, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4365, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4373; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4365, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (!__pyx_t_12) {
} else {
@@ -46848,7 +46132,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_L14_bool_binop_done:;
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4374
+ /* "netCDF4/_netCDF4.pyx":4366
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* with nogil: # <<<<<<<<<<<<<<
@@ -46862,7 +46146,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":4375
+ /* "netCDF4/_netCDF4.pyx":4367
* if sum(stride) == ndims or ndims == 0:
* with nogil:
* ierr = nc_get_vara(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -46872,7 +46156,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_v_ierr = nc_get_vara(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_data->data);
}
- /* "netCDF4/_netCDF4.pyx":4374
+ /* "netCDF4/_netCDF4.pyx":4366
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* with nogil: # <<<<<<<<<<<<<<
@@ -46890,7 +46174,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
}
- /* "netCDF4/_netCDF4.pyx":4373
+ /* "netCDF4/_netCDF4.pyx":4365
* data = numpy.empty(shapeout, self.dtype)
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
@@ -46900,7 +46184,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
goto __pyx_L13;
}
- /* "netCDF4/_netCDF4.pyx":4378
+ /* "netCDF4/_netCDF4.pyx":4370
* startp, countp, data.data)
* else:
* with nogil: # <<<<<<<<<<<<<<
@@ -46915,7 +46199,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":4379
+ /* "netCDF4/_netCDF4.pyx":4371
* else:
* with nogil:
* ierr = nc_get_vars(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -46925,7 +46209,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_v_ierr = nc_get_vars(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_stridep, __pyx_v_data->data);
}
- /* "netCDF4/_netCDF4.pyx":4378
+ /* "netCDF4/_netCDF4.pyx":4370
* startp, countp, data.data)
* else:
* with nogil: # <<<<<<<<<<<<<<
@@ -46945,7 +46229,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
__pyx_L13:;
- /* "netCDF4/_netCDF4.pyx":4381
+ /* "netCDF4/_netCDF4.pyx":4373
* ierr = nc_get_vars(self._grpid, self._varid,
* startp, countp, stridep, data.data)
* if ierr == NC_EINVALCOORDS: # <<<<<<<<<<<<<<
@@ -46955,7 +46239,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_5 = ((__pyx_v_ierr == NC_EINVALCOORDS) != 0);
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4382
+ /* "netCDF4/_netCDF4.pyx":4374
* startp, countp, stridep, data.data)
* if ierr == NC_EINVALCOORDS:
* raise IndexError # <<<<<<<<<<<<<<
@@ -46963,9 +46247,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
__Pyx_Raise(__pyx_builtin_IndexError, 0, 0, 0);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4382; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4374, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4381
+ /* "netCDF4/_netCDF4.pyx":4373
* ierr = nc_get_vars(self._grpid, self._varid,
* startp, countp, stridep, data.data)
* if ierr == NC_EINVALCOORDS: # <<<<<<<<<<<<<<
@@ -46974,7 +46258,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4383
+ /* "netCDF4/_netCDF4.pyx":4375
* if ierr == NC_EINVALCOORDS:
* raise IndexError
* elif ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -46984,7 +46268,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_5 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4384
+ /* "netCDF4/_netCDF4.pyx":4376
* raise IndexError
* elif ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -46992,22 +46276,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* # allocate array of correct primitive type.
*/
__pyx_t_13 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4384; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4376, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4383
+ /* "netCDF4/_netCDF4.pyx":4375
* if ierr == NC_EINVALCOORDS:
* raise IndexError
* elif ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -47016,7 +46300,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4370
+ /* "netCDF4/_netCDF4.pyx":4362
* stridep[n] = stride[n]
* sl.append(slice(None,None, 1))
* if self._isprimitive or self._iscompound or self._isenum: # <<<<<<<<<<<<<<
@@ -47026,26 +46310,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
goto __pyx_L9;
}
- /* "netCDF4/_netCDF4.pyx":4385
+ /* "netCDF4/_netCDF4.pyx":4377
* elif ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* elif self._isvlen: # <<<<<<<<<<<<<<
* # allocate array of correct primitive type.
* data = numpy.empty(shapeout, 'O')
*/
- __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4385; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_self->_isvlen); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4377, __pyx_L1_error)
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4387
+ /* "netCDF4/_netCDF4.pyx":4379
* elif self._isvlen:
* # allocate array of correct primitive type.
* data = numpy.empty(shapeout, 'O') # <<<<<<<<<<<<<<
* # flatten data array.
* data = data.flatten()
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4387; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4387; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_empty); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -47060,7 +46344,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_2 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4387; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -47071,22 +46355,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__Pyx_INCREF(__pyx_n_s_O);
__Pyx_GIVEREF(__pyx_n_s_O);
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_2, __pyx_n_s_O);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4387; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4387; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4379, __pyx_L1_error)
__pyx_v_data = ((PyArrayObject *)__pyx_t_1);
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4389
+ /* "netCDF4/_netCDF4.pyx":4381
* data = numpy.empty(shapeout, 'O')
* # flatten data array.
* data = data.flatten() # <<<<<<<<<<<<<<
* totelem = PyArray_SIZE(data)
* if self.dtype == str:
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_flatten); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4389; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_flatten); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_10 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -47099,78 +46383,78 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
}
if (__pyx_t_10) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_10); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4389; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4381, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4389; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4381, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4389; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4381, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_1));
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4390
+ /* "netCDF4/_netCDF4.pyx":4382
* # flatten data array.
* data = data.flatten()
* totelem = PyArray_SIZE(data) # <<<<<<<<<<<<<<
* if self.dtype == str:
* # vlen string (NC_STRING)
*/
- __pyx_t_1 = __Pyx_PyInt_From_npy_intp(PyArray_SIZE(__pyx_v_data)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4390; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_npy_intp(PyArray_SIZE(__pyx_v_data)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_totelem = __pyx_t_1;
__pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":4391
+ /* "netCDF4/_netCDF4.pyx":4383
* data = data.flatten()
* totelem = PyArray_SIZE(data)
* if self.dtype == str: # <<<<<<<<<<<<<<
* # vlen string (NC_STRING)
* # allocate pointer array to hold string data.
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4391; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4391; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4383, __pyx_L1_error)
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4383, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4394
+ /* "netCDF4/_netCDF4.pyx":4386
* # vlen string (NC_STRING)
* # allocate pointer array to hold string data.
* strdata = <char **>malloc(sizeof(char *) * totelem) # <<<<<<<<<<<<<<
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0:
*/
- __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(char *))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_FromSize_t((sizeof(char *))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_v_totelem); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Multiply(__pyx_t_1, __pyx_v_totelem); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4386, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_strdata = ((char **)malloc(__pyx_t_8));
- /* "netCDF4/_netCDF4.pyx":4396
+ /* "netCDF4/_netCDF4.pyx":4388
* strdata = <char **>malloc(sizeof(char *) * totelem)
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_get_vara(self._grpid, self._varid,
*/
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_stride);
__Pyx_GIVEREF(__pyx_v_stride);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_stride);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = PyObject_RichCompare(__pyx_t_1, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyObject_RichCompare(__pyx_t_1, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4388, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4388, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
if (!__pyx_t_12) {
} else {
@@ -47182,7 +46466,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_L25_bool_binop_done:;
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4397
+ /* "netCDF4/_netCDF4.pyx":4389
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* with nogil: # <<<<<<<<<<<<<<
@@ -47196,7 +46480,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":4398
+ /* "netCDF4/_netCDF4.pyx":4390
* if sum(stride) == ndims or ndims == 0:
* with nogil:
* ierr = nc_get_vara(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -47206,7 +46490,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_v_ierr = nc_get_vara(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_strdata);
}
- /* "netCDF4/_netCDF4.pyx":4397
+ /* "netCDF4/_netCDF4.pyx":4389
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* with nogil: # <<<<<<<<<<<<<<
@@ -47224,7 +46508,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
}
- /* "netCDF4/_netCDF4.pyx":4396
+ /* "netCDF4/_netCDF4.pyx":4388
* strdata = <char **>malloc(sizeof(char *) * totelem)
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
@@ -47234,7 +46518,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
goto __pyx_L24;
}
- /* "netCDF4/_netCDF4.pyx":4402
+ /* "netCDF4/_netCDF4.pyx":4394
* else:
* # FIXME: is this a bug in netCDF4?
* raise IndexError('strides must all be 1 for string variables') # <<<<<<<<<<<<<<
@@ -47242,15 +46526,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* # startp, countp, stridep, strdata)
*/
/*else*/ {
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4402; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__78, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4402; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4394, __pyx_L1_error)
}
__pyx_L24:;
- /* "netCDF4/_netCDF4.pyx":4405
+ /* "netCDF4/_netCDF4.pyx":4397
* #ierr = nc_get_vars(self._grpid, self._varid,
* # startp, countp, stridep, strdata)
* if ierr == NC_EINVALCOORDS: # <<<<<<<<<<<<<<
@@ -47260,7 +46544,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_5 = ((__pyx_v_ierr == NC_EINVALCOORDS) != 0);
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4406
+ /* "netCDF4/_netCDF4.pyx":4398
* # startp, countp, stridep, strdata)
* if ierr == NC_EINVALCOORDS:
* raise IndexError # <<<<<<<<<<<<<<
@@ -47268,9 +46552,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
__Pyx_Raise(__pyx_builtin_IndexError, 0, 0, 0);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4406; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4398, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4405
+ /* "netCDF4/_netCDF4.pyx":4397
* #ierr = nc_get_vars(self._grpid, self._varid,
* # startp, countp, stridep, strdata)
* if ierr == NC_EINVALCOORDS: # <<<<<<<<<<<<<<
@@ -47279,7 +46563,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4407
+ /* "netCDF4/_netCDF4.pyx":4399
* if ierr == NC_EINVALCOORDS:
* raise IndexError
* elif ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -47289,7 +46573,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_5 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4408
+ /* "netCDF4/_netCDF4.pyx":4400
* raise IndexError
* elif ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -47297,22 +46581,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* # contents of strdata.
*/
__pyx_t_13 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_10 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4400, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4400, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_10);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4400, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4400, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4407
+ /* "netCDF4/_netCDF4.pyx":4399
* if ierr == NC_EINVALCOORDS:
* raise IndexError
* elif ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -47321,29 +46605,29 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4411
+ /* "netCDF4/_netCDF4.pyx":4403
* # loop over elements of object array, fill array with
* # contents of strdata.
* for i from 0<=i<totelem: # <<<<<<<<<<<<<<
* data[i] = strdata[i].decode(default_encoding)
* # reshape the output array
*/
- __pyx_t_14 = __Pyx_PyInt_As_long(__pyx_v_totelem); if (unlikely((__pyx_t_14 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyInt_As_long(__pyx_v_totelem); if (unlikely((__pyx_t_14 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 4403, __pyx_L1_error)
for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_14; __pyx_v_i++) {
- /* "netCDF4/_netCDF4.pyx":4412
+ /* "netCDF4/_netCDF4.pyx":4404
* # contents of strdata.
* for i from 0<=i<totelem:
* data[i] = strdata[i].decode(default_encoding) # <<<<<<<<<<<<<<
* # reshape the output array
* data = numpy.reshape(data, shapeout)
*/
- __pyx_t_6 = __Pyx_PyBytes_FromString((__pyx_v_strdata[__pyx_v_i])); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyBytes_FromString((__pyx_v_strdata[__pyx_v_i])); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -47356,35 +46640,35 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
}
if (!__pyx_t_4) {
- __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4404, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_10);
} else {
- __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_15, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_data), __pyx_v_i, __pyx_t_10, long, 1, __Pyx_PyInt_From_long, 0, 1, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_data), __pyx_v_i, __pyx_t_10, long, 1, __Pyx_PyInt_From_long, 0, 1, 1) < 0)) __PYX_ERR(0, 4404, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
- /* "netCDF4/_netCDF4.pyx":4414
+ /* "netCDF4/_netCDF4.pyx":4406
* data[i] = strdata[i].decode(default_encoding)
* # reshape the output array
* data = numpy.reshape(data, shapeout) # <<<<<<<<<<<<<<
* # free string data internally allocated in netcdf C lib
* ierr = nc_free_string(totelem, strdata)
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4414; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_reshape); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4414; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_reshape); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -47399,7 +46683,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_2 = 1;
}
}
- __pyx_t_6 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4414; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_1) {
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __pyx_t_1 = NULL;
@@ -47410,25 +46694,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__Pyx_INCREF(__pyx_v_shapeout);
__Pyx_GIVEREF(__pyx_v_shapeout);
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_2, __pyx_v_shapeout);
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4414; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- if (!(likely(((__pyx_t_10) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_10, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4414; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_10) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_10, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4406, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_10));
__pyx_t_10 = 0;
- /* "netCDF4/_netCDF4.pyx":4416
+ /* "netCDF4/_netCDF4.pyx":4408
* data = numpy.reshape(data, shapeout)
* # free string data internally allocated in netcdf C lib
* ierr = nc_free_string(totelem, strdata) # <<<<<<<<<<<<<<
* # free the pointer array
* free(strdata)
*/
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_v_totelem); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4416; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_v_totelem); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4408, __pyx_L1_error)
__pyx_v_ierr = nc_free_string(__pyx_t_8, __pyx_v_strdata);
- /* "netCDF4/_netCDF4.pyx":4418
+ /* "netCDF4/_netCDF4.pyx":4410
* ierr = nc_free_string(totelem, strdata)
* # free the pointer array
* free(strdata) # <<<<<<<<<<<<<<
@@ -47437,7 +46721,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
free(__pyx_v_strdata);
- /* "netCDF4/_netCDF4.pyx":4391
+ /* "netCDF4/_netCDF4.pyx":4383
* data = data.flatten()
* totelem = PyArray_SIZE(data)
* if self.dtype == str: # <<<<<<<<<<<<<<
@@ -47447,7 +46731,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
goto __pyx_L23;
}
- /* "netCDF4/_netCDF4.pyx":4422
+ /* "netCDF4/_netCDF4.pyx":4414
* # regular vlen
* # allocate struct array to hold vlen data.
* vldata = <nc_vlen_t *>malloc(totelem*sizeof(nc_vlen_t)) # <<<<<<<<<<<<<<
@@ -47455,36 +46739,36 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* if sum(stride) == ndims or ndims == 0:
*/
/*else*/ {
- __pyx_t_10 = __Pyx_PyInt_FromSize_t((sizeof(nc_vlen_t))); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4422; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_FromSize_t((sizeof(nc_vlen_t))); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4414, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_15 = PyNumber_Multiply(__pyx_v_totelem, __pyx_t_10); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4422; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyNumber_Multiply(__pyx_v_totelem, __pyx_t_10); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4414, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_15); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4422; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_15); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4414, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__pyx_v_vldata = ((nc_vlen_t *)malloc(__pyx_t_8));
- /* "netCDF4/_netCDF4.pyx":4424
+ /* "netCDF4/_netCDF4.pyx":4416
* vldata = <nc_vlen_t *>malloc(totelem*sizeof(nc_vlen_t))
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
* with nogil:
* ierr = nc_get_vara(self._grpid, self._varid,
*/
- __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4424; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4416, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_INCREF(__pyx_v_stride);
__Pyx_GIVEREF(__pyx_v_stride);
PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_v_stride);
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_15, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4424; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_15, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4416, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4424; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyInt_From_int(__pyx_v_ndims); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4416, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- __pyx_t_6 = PyObject_RichCompare(__pyx_t_10, __pyx_t_15, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4424; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_RichCompare(__pyx_t_10, __pyx_t_15, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4416, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4424; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4416, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (!__pyx_t_12) {
} else {
@@ -47496,7 +46780,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_L34_bool_binop_done:;
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4425
+ /* "netCDF4/_netCDF4.pyx":4417
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* with nogil: # <<<<<<<<<<<<<<
@@ -47510,7 +46794,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
#endif
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":4426
+ /* "netCDF4/_netCDF4.pyx":4418
* if sum(stride) == ndims or ndims == 0:
* with nogil:
* ierr = nc_get_vara(self._grpid, self._varid, # <<<<<<<<<<<<<<
@@ -47520,7 +46804,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_v_ierr = nc_get_vara(__pyx_v_self->_grpid, __pyx_v_self->_varid, __pyx_v_startp, __pyx_v_countp, __pyx_v_vldata);
}
- /* "netCDF4/_netCDF4.pyx":4425
+ /* "netCDF4/_netCDF4.pyx":4417
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0:
* with nogil: # <<<<<<<<<<<<<<
@@ -47538,7 +46822,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
}
- /* "netCDF4/_netCDF4.pyx":4424
+ /* "netCDF4/_netCDF4.pyx":4416
* vldata = <nc_vlen_t *>malloc(totelem*sizeof(nc_vlen_t))
* # strides all 1 or scalar variable, use get_vara (faster)
* if sum(stride) == ndims or ndims == 0: # <<<<<<<<<<<<<<
@@ -47548,7 +46832,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
goto __pyx_L33;
}
- /* "netCDF4/_netCDF4.pyx":4429
+ /* "netCDF4/_netCDF4.pyx":4421
* startp, countp, vldata)
* else:
* raise IndexError('strides must all be 1 for vlen variables') # <<<<<<<<<<<<<<
@@ -47556,15 +46840,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* # startp, countp, stridep, vldata)
*/
/*else*/ {
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__87, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4429; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4421, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4429; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4421, __pyx_L1_error)
}
__pyx_L33:;
- /* "netCDF4/_netCDF4.pyx":4432
+ /* "netCDF4/_netCDF4.pyx":4424
* #ierr = nc_get_vars(self._grpid, self._varid,
* # startp, countp, stridep, vldata)
* if ierr == NC_EINVALCOORDS: # <<<<<<<<<<<<<<
@@ -47574,7 +46858,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_5 = ((__pyx_v_ierr == NC_EINVALCOORDS) != 0);
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4433
+ /* "netCDF4/_netCDF4.pyx":4425
* # startp, countp, stridep, vldata)
* if ierr == NC_EINVALCOORDS:
* raise IndexError # <<<<<<<<<<<<<<
@@ -47582,9 +46866,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
__Pyx_Raise(__pyx_builtin_IndexError, 0, 0, 0);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4433; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4425, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4432
+ /* "netCDF4/_netCDF4.pyx":4424
* #ierr = nc_get_vars(self._grpid, self._varid,
* # startp, countp, stridep, vldata)
* if ierr == NC_EINVALCOORDS: # <<<<<<<<<<<<<<
@@ -47593,7 +46877,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4434
+ /* "netCDF4/_netCDF4.pyx":4426
* if ierr == NC_EINVALCOORDS:
* raise IndexError
* elif ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -47603,7 +46887,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_5 = ((__pyx_v_ierr != NC_NOERR) != 0);
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4435
+ /* "netCDF4/_netCDF4.pyx":4427
* raise IndexError
* elif ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii')) # <<<<<<<<<<<<<<
@@ -47611,22 +46895,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* # contents of vlarray struct, put array in object array.
*/
__pyx_t_13 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_6 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4435; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_decode_c_string(__pyx_t_13, 0, strlen(__pyx_t_13), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4427, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4435; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4427, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_INCREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_15, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4435; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_15, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4427, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4435; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4427, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":4434
+ /* "netCDF4/_netCDF4.pyx":4426
* if ierr == NC_EINVALCOORDS:
* raise IndexError
* elif ierr != NC_NOERR: # <<<<<<<<<<<<<<
@@ -47635,17 +46919,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
}
- /* "netCDF4/_netCDF4.pyx":4438
+ /* "netCDF4/_netCDF4.pyx":4430
* # loop over elements of object array, fill array with
* # contents of vlarray struct, put array in object array.
* for i from 0<=i<totelem: # <<<<<<<<<<<<<<
* arrlen = vldata[i].len
* dataarr = numpy.empty(arrlen, self.dtype)
*/
- __pyx_t_14 = __Pyx_PyInt_As_long(__pyx_v_totelem); if (unlikely((__pyx_t_14 == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyInt_As_long(__pyx_v_totelem); if (unlikely((__pyx_t_14 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 4430, __pyx_L1_error)
for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_14; __pyx_v_i++) {
- /* "netCDF4/_netCDF4.pyx":4439
+ /* "netCDF4/_netCDF4.pyx":4431
* # contents of vlarray struct, put array in object array.
* for i from 0<=i<totelem:
* arrlen = vldata[i].len # <<<<<<<<<<<<<<
@@ -47655,19 +46939,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_8 = (__pyx_v_vldata[__pyx_v_i]).len;
__pyx_v_arrlen = __pyx_t_8;
- /* "netCDF4/_netCDF4.pyx":4440
+ /* "netCDF4/_netCDF4.pyx":4432
* for i from 0<=i<totelem:
* arrlen = vldata[i].len
* dataarr = numpy.empty(arrlen, self.dtype) # <<<<<<<<<<<<<<
* #dataarr.data = <char *>vldata[i].p
* memcpy(<void*>dataarr.data, vldata[i].p, dataarr.nbytes)
*/
- __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_empty); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- __pyx_t_15 = __Pyx_PyInt_FromSize_t(__pyx_v_arrlen); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyInt_FromSize_t(__pyx_v_arrlen); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__pyx_t_1 = NULL;
__pyx_t_2 = 0;
@@ -47681,7 +46965,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_2 = 1;
}
}
- __pyx_t_4 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (__pyx_t_1) {
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __pyx_t_1 = NULL;
@@ -47692,47 +46976,47 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__Pyx_GIVEREF(__pyx_v_self->dtype);
PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_2, __pyx_v_self->dtype);
__pyx_t_15 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4440; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4432, __pyx_L1_error)
__Pyx_XDECREF_SET(__pyx_v_dataarr, ((PyArrayObject *)__pyx_t_6));
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":4442
+ /* "netCDF4/_netCDF4.pyx":4434
* dataarr = numpy.empty(arrlen, self.dtype)
* #dataarr.data = <char *>vldata[i].p
* memcpy(<void*>dataarr.data, vldata[i].p, dataarr.nbytes) # <<<<<<<<<<<<<<
* data[i] = dataarr
* # reshape the output array
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dataarr), __pyx_n_s_nbytes); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_dataarr), __pyx_n_s_nbytes); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4434, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_t_6); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4434, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
memcpy(((void *)__pyx_v_dataarr->data), (__pyx_v_vldata[__pyx_v_i]).p, __pyx_t_8);
- /* "netCDF4/_netCDF4.pyx":4443
+ /* "netCDF4/_netCDF4.pyx":4435
* #dataarr.data = <char *>vldata[i].p
* memcpy(<void*>dataarr.data, vldata[i].p, dataarr.nbytes)
* data[i] = dataarr # <<<<<<<<<<<<<<
* # reshape the output array
* data = numpy.reshape(data, shapeout)
*/
- if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_data), __pyx_v_i, ((PyObject *)__pyx_v_dataarr), long, 1, __Pyx_PyInt_From_long, 0, 1, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4443; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_data), __pyx_v_i, ((PyObject *)__pyx_v_dataarr), long, 1, __Pyx_PyInt_From_long, 0, 1, 1) < 0)) __PYX_ERR(0, 4435, __pyx_L1_error)
}
- /* "netCDF4/_netCDF4.pyx":4445
+ /* "netCDF4/_netCDF4.pyx":4437
* data[i] = dataarr
* # reshape the output array
* data = numpy.reshape(data, shapeout) # <<<<<<<<<<<<<<
* # free vlen data internally allocated in netcdf C lib
* ierr = nc_free_vlens(totelem, vldata)
*/
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_reshape); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_reshape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = NULL;
@@ -47747,7 +47031,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_2 = 1;
}
}
- __pyx_t_15 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(2+__pyx_t_2); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
if (__pyx_t_10) {
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_10); __pyx_t_10 = NULL;
@@ -47758,25 +47042,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__Pyx_INCREF(__pyx_v_shapeout);
__Pyx_GIVEREF(__pyx_v_shapeout);
PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_2, __pyx_v_shapeout);
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4437, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_6));
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":4447
+ /* "netCDF4/_netCDF4.pyx":4439
* data = numpy.reshape(data, shapeout)
* # free vlen data internally allocated in netcdf C lib
* ierr = nc_free_vlens(totelem, vldata) # <<<<<<<<<<<<<<
* # free the pointer array
* free(vldata)
*/
- __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_v_totelem); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4447; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_size_t(__pyx_v_totelem); if (unlikely((__pyx_t_8 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4439, __pyx_L1_error)
__pyx_v_ierr = nc_free_vlens(__pyx_t_8, __pyx_v_vldata);
- /* "netCDF4/_netCDF4.pyx":4449
+ /* "netCDF4/_netCDF4.pyx":4441
* ierr = nc_free_vlens(totelem, vldata)
* # free the pointer array
* free(vldata) # <<<<<<<<<<<<<<
@@ -47787,7 +47071,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
__pyx_L23:;
- /* "netCDF4/_netCDF4.pyx":4385
+ /* "netCDF4/_netCDF4.pyx":4377
* elif ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* elif self._isvlen: # <<<<<<<<<<<<<<
@@ -47797,7 +47081,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
__pyx_L9:;
- /* "netCDF4/_netCDF4.pyx":4450
+ /* "netCDF4/_netCDF4.pyx":4442
* # free the pointer array
* free(vldata)
* free(startp) # <<<<<<<<<<<<<<
@@ -47806,7 +47090,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
free(__pyx_v_startp);
- /* "netCDF4/_netCDF4.pyx":4451
+ /* "netCDF4/_netCDF4.pyx":4443
* free(vldata)
* free(startp)
* free(countp) # <<<<<<<<<<<<<<
@@ -47815,7 +47099,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
free(__pyx_v_countp);
- /* "netCDF4/_netCDF4.pyx":4452
+ /* "netCDF4/_netCDF4.pyx":4444
* free(startp)
* free(countp)
* free(stridep) # <<<<<<<<<<<<<<
@@ -47824,7 +47108,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
free(__pyx_v_stridep);
- /* "netCDF4/_netCDF4.pyx":4453
+ /* "netCDF4/_netCDF4.pyx":4445
* free(countp)
* free(stridep)
* if negstride: # <<<<<<<<<<<<<<
@@ -47834,17 +47118,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
__pyx_t_5 = (__pyx_v_negstride != 0);
if (__pyx_t_5) {
- /* "netCDF4/_netCDF4.pyx":4455
+ /* "netCDF4/_netCDF4.pyx":4447
* if negstride:
* # reverse data along axes with negative strides.
* data = data[sl].copy() # make a copy so data is contiguous. # <<<<<<<<<<<<<<
- * if not self.dimensions:
- * return data[0] # a scalar
+ * # netcdf-c always returns data in native byte order,
+ * # regardless of variable endian-ness. Here we swap the
*/
- if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4455; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_4 = PyObject_GetItem(((PyObject *)__pyx_v_data), __pyx_v_sl); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4455; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); __PYX_ERR(0, 4447, __pyx_L1_error) }
+ __pyx_t_4 = PyObject_GetItem(((PyObject *)__pyx_v_data), __pyx_v_sl); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_copy); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_copy); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4447, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -47858,18 +47142,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
}
}
if (__pyx_t_4) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4447, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_15); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4447, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_7netCDF4_8_netCDF4_ndarray))))) __PYX_ERR(0, 4447, __pyx_L1_error)
__Pyx_XDECREF_SET(__pyx_v_data, ((PyArrayObject *)__pyx_t_6));
__pyx_t_6 = 0;
- /* "netCDF4/_netCDF4.pyx":4453
+ /* "netCDF4/_netCDF4.pyx":4445
* free(countp)
* free(stridep)
* if negstride: # <<<<<<<<<<<<<<
@@ -47878,38 +47162,156 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
}
+ /* "netCDF4/_netCDF4.pyx":4453
+ * # dtype of the returned numpy array matches the variable dtype.
+ * # (pull request #555, issue #554).
+ * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
+ * (self.endian() == 'little' and is_native_big):
+ * data.byteswap(True) # in-place byteswap
+ */
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4453, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_15);
+ __pyx_t_4 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_15))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_15);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_15, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4453, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4453, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+ __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_big, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4453, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ if (!__pyx_t_12) {
+ goto __pyx_L45_next_or;
+ } else {
+ }
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_little); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4453, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4453, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ if (!__pyx_t_12) {
+ } else {
+ __pyx_t_5 = __pyx_t_12;
+ goto __pyx_L44_bool_binop_done;
+ }
+ __pyx_L45_next_or:;
+
+ /* "netCDF4/_netCDF4.pyx":4454
+ * # (pull request #555, issue #554).
+ * if (self.endian() == 'big' and is_native_little) or\
+ * (self.endian() == 'little' and is_native_big): # <<<<<<<<<<<<<<
+ * data.byteswap(True) # in-place byteswap
+ * if not self.dimensions:
+ */
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_endian); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4454, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_15);
+ __pyx_t_4 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_15))) {
+ __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_15);
+ if (likely(__pyx_t_4)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_15);
+ __Pyx_INCREF(__pyx_t_4);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_15, function);
+ }
+ }
+ if (__pyx_t_4) {
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4454, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ } else {
+ __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4454, __pyx_L1_error)
+ }
+ __Pyx_GOTREF(__pyx_t_6);
+ __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+ __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_little, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4454, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ if (__pyx_t_12) {
+ } else {
+ __pyx_t_5 = __pyx_t_12;
+ goto __pyx_L44_bool_binop_done;
+ }
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_is_native_big); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4454, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 4454, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_5 = __pyx_t_12;
+ __pyx_L44_bool_binop_done:;
+
+ /* "netCDF4/_netCDF4.pyx":4453
+ * # dtype of the returned numpy array matches the variable dtype.
+ * # (pull request #555, issue #554).
+ * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
+ * (self.endian() == 'little' and is_native_big):
+ * data.byteswap(True) # in-place byteswap
+ */
+ if (__pyx_t_5) {
+
+ /* "netCDF4/_netCDF4.pyx":4455
+ * if (self.endian() == 'big' and is_native_little) or\
+ * (self.endian() == 'little' and is_native_big):
+ * data.byteswap(True) # in-place byteswap # <<<<<<<<<<<<<<
+ * if not self.dimensions:
+ * return data[0] # a scalar
+ */
+ if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); __PYX_ERR(0, 4455, __pyx_L1_error) }
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_data), __pyx_n_s_byteswap); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4455, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4455, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_15);
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
+
+ /* "netCDF4/_netCDF4.pyx":4453
+ * # dtype of the returned numpy array matches the variable dtype.
+ * # (pull request #555, issue #554).
+ * if (self.endian() == 'big' and is_native_little) or\ # <<<<<<<<<<<<<<
+ * (self.endian() == 'little' and is_native_big):
+ * data.byteswap(True) # in-place byteswap
+ */
+ }
+
/* "netCDF4/_netCDF4.pyx":4456
- * # reverse data along axes with negative strides.
- * data = data[sl].copy() # make a copy so data is contiguous.
+ * (self.endian() == 'little' and is_native_big):
+ * data.byteswap(True) # in-place byteswap
* if not self.dimensions: # <<<<<<<<<<<<<<
* return data[0] # a scalar
* elif squeeze_out:
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_6);
- __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_dimensions); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4456, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_15);
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4456, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__pyx_t_12 = ((!__pyx_t_5) != 0);
if (__pyx_t_12) {
/* "netCDF4/_netCDF4.pyx":4457
- * data = data[sl].copy() # make a copy so data is contiguous.
+ * data.byteswap(True) # in-place byteswap
* if not self.dimensions:
* return data[0] # a scalar # <<<<<<<<<<<<<<
* elif squeeze_out:
* return numpy.squeeze(data)
*/
__Pyx_XDECREF(__pyx_r);
- if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4457; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_6 = __Pyx_GetItemInt(((PyObject *)__pyx_v_data), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4457; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_6);
- __pyx_r = __pyx_t_6;
- __pyx_t_6 = 0;
+ if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); __PYX_ERR(0, 4457, __pyx_L1_error) }
+ __pyx_t_15 = __Pyx_GetItemInt(((PyObject *)__pyx_v_data), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4457, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_15);
+ __pyx_r = __pyx_t_15;
+ __pyx_t_15 = 0;
goto __pyx_L0;
/* "netCDF4/_netCDF4.pyx":4456
- * # reverse data along axes with negative strides.
- * data = data[sl].copy() # make a copy so data is contiguous.
+ * (self.endian() == 'little' and is_native_big):
+ * data.byteswap(True) # in-place byteswap
* if not self.dimensions: # <<<<<<<<<<<<<<
* return data[0] # a scalar
* elif squeeze_out:
@@ -47934,39 +47336,39 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
* return data
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4459; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_15);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_squeeze); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4459; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4459, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_squeeze); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4459, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4459; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_15 = NULL;
+ __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
+ if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); __PYX_ERR(0, 4459, __pyx_L1_error) }
+ __pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
- __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_4);
- if (likely(__pyx_t_15)) {
+ __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
+ if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
- __Pyx_INCREF(__pyx_t_15);
+ __Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
- if (!__pyx_t_15) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_v_data)); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4459; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_6);
+ if (!__pyx_t_6) {
+ __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_4, ((PyObject *)__pyx_v_data)); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4459, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_15);
} else {
- __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4459; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4459, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_15); __pyx_t_15 = NULL;
+ __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(((PyObject *)__pyx_v_data));
__Pyx_GIVEREF(((PyObject *)__pyx_v_data));
PyTuple_SET_ITEM(__pyx_t_10, 0+1, ((PyObject *)__pyx_v_data));
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4459; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_6);
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_10, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 4459, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_r = __pyx_t_6;
- __pyx_t_6 = 0;
+ __pyx_r = __pyx_t_15;
+ __pyx_t_15 = 0;
goto __pyx_L0;
/* "netCDF4/_netCDF4.pyx":4458
@@ -47987,13 +47389,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4461; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
+ if (unlikely(!__pyx_v_data)) { __Pyx_RaiseUnboundLocalError("data"); __PYX_ERR(0, 4461, __pyx_L1_error) }
__Pyx_INCREF(((PyObject *)__pyx_v_data));
__pyx_r = ((PyObject *)__pyx_v_data);
goto __pyx_L0;
}
- /* "netCDF4/_netCDF4.pyx":4327
+ /* "netCDF4/_netCDF4.pyx":4319
* free(stridep)
*
* def _get(self,start,count,stride): # <<<<<<<<<<<<<<
@@ -48022,7 +47424,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_66_get(struct __pyx_obj_7
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2847
+/* "netCDF4/_netCDF4.pyx":2857
* **`size`**: The number of stored elements.
* """
* cdef public int _varid, _grpid, _nunlimdim # <<<<<<<<<<<<<<
@@ -48047,12 +47449,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6_varid___get__(struct __
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_varid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2847; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_varid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2857, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -48086,11 +47485,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_6_varid_2__set__(struct __pyx_o
int __pyx_r;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2847; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error)
__pyx_v_self->_varid = __pyx_t_1;
/* function exit code */
@@ -48121,12 +47517,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_6_grpid___get__(struct __
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2847; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2857, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -48160,11 +47553,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_6_grpid_2__set__(struct __pyx_o
int __pyx_r;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2847; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error)
__pyx_v_self->_grpid = __pyx_t_1;
/* function exit code */
@@ -48195,12 +47585,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8Variable_10_nunlimdim___get__(stru
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_nunlimdim); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2847; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->_nunlimdim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2857, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -48234,11 +47621,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_10_nunlimdim_2__set__(struct __
int __pyx_r;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2847; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2857, __pyx_L1_error)
__pyx_v_self->_nunlimdim = __pyx_t_1;
/* function exit code */
@@ -48252,7 +47636,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_10_nunlimdim_2__set__(struct __
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2848
+/* "netCDF4/_netCDF4.pyx":2858
* """
* cdef public int _varid, _grpid, _nunlimdim
* cdef public _name, ndim, dtype, mask, scale, _isprimitive, _iscompound,\ # <<<<<<<<<<<<<<
@@ -48869,7 +48253,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_11_iscompound_4__del__(struct _
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2849
+/* "netCDF4/_netCDF4.pyx":2859
* cdef public int _varid, _grpid, _nunlimdim
* cdef public _name, ndim, dtype, mask, scale, _isprimitive, _iscompound,\
* _isvlen, _isenum, _grp, _cmptype, _vltype, _enumtype,\ # <<<<<<<<<<<<<<
@@ -49399,7 +48783,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8Variable_9_enumtype_4__del__(struct __py
return __pyx_r;
}
-/* "netCDF4/_netCDF4.pyx":2850
+/* "netCDF4/_netCDF4.pyx":2860
* cdef public _name, ndim, dtype, mask, scale, _isprimitive, _iscompound,\
* _isvlen, _isenum, _grp, _cmptype, _vltype, _enumtype,\
* __orthogonal_indexing__, _has_lsd # <<<<<<<<<<<<<<
@@ -49600,9 +48984,6 @@ static int __pyx_pw_7netCDF4_8_netCDF4_12CompoundType_1__init__(PyObject *__pyx_
PyObject *__pyx_v_dt = 0;
PyObject *__pyx_v_dtype_name = 0;
PyObject *__pyx_v_kwargs = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -49629,16 +49010,16 @@ static int __pyx_pw_7netCDF4_8_netCDF4_12CompoundType_1__init__(PyObject *__pyx_
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dt)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4482; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(0, 4482, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dtype_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4482; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(0, 4482, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4482; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 4482, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
@@ -49653,7 +49034,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_12CompoundType_1__init__(PyObject *__pyx_
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4482; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4482, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("netCDF4._netCDF4.CompoundType.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
@@ -49679,9 +49060,6 @@ static int __pyx_pf_7netCDF4_8_netCDF4_12CompoundType___init__(struct __pyx_obj_
int __pyx_t_5;
int __pyx_t_6;
nc_type __pyx_t_7;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
__Pyx_INCREF(__pyx_v_dt);
@@ -49692,20 +49070,20 @@ static int __pyx_pf_7netCDF4_8_netCDF4_12CompoundType___init__(struct __pyx_obj_
* if 'typeid' in kwargs:
* xtype = kwargs['typeid']
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_dt);
__Pyx_GIVEREF(__pyx_v_dt);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_dt);
- __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_align, Py_True) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_align, Py_True) < 0) __PYX_ERR(0, 4507, __pyx_L1_error)
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -49720,7 +49098,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_12CompoundType___init__(struct __pyx_obj_
* xtype = kwargs['typeid']
* else:
*/
- __pyx_t_5 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_typeid, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4508; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_typeid, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4508, __pyx_L1_error)
__pyx_t_6 = (__pyx_t_5 != 0);
if (__pyx_t_6) {
@@ -49731,9 +49109,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_12CompoundType___init__(struct __pyx_obj_
* else:
* xtype = _def_compound(grp, dt, dtype_name)
*/
- __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_typeid); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4509; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_typeid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4509, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = __Pyx_PyInt_As_nc_type(__pyx_t_4); if (unlikely((__pyx_t_7 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4509; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_nc_type(__pyx_t_4); if (unlikely((__pyx_t_7 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4509, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_xtype = __pyx_t_7;
@@ -49755,9 +49133,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_12CompoundType___init__(struct __pyx_obj_
* self.dtype = dt
*/
/*else*/ {
- __pyx_t_4 = __pyx_f_7netCDF4_8_netCDF4__def_compound(__pyx_v_grp, __pyx_v_dt, __pyx_v_dtype_name); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4511; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __pyx_f_7netCDF4_8_netCDF4__def_compound(__pyx_v_grp, __pyx_v_dt, __pyx_v_dtype_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = __Pyx_PyInt_As_nc_type(__pyx_t_4); if (unlikely((__pyx_t_7 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4511; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_As_nc_type(__pyx_t_4); if (unlikely((__pyx_t_7 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4511, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_xtype = __pyx_t_7;
}
@@ -49852,9 +49230,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_2__repr__(struct __p
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
/* "netCDF4/_netCDF4.pyx":4517
@@ -49864,9 +49239,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_2__repr__(struct __p
* return self.__unicode__()
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4517; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4517, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4517; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4517, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
@@ -49878,7 +49253,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_2__repr__(struct __p
* return unicode(self).encode(default_encoding)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4518, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -49891,10 +49266,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_2__repr__(struct __p
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4518, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4518; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4518, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -49920,18 +49295,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_2__repr__(struct __p
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -49944,17 +49319,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_2__repr__(struct __p
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4520, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -50014,9 +49389,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_4__unicode__(struct
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__unicode__", 0);
/* "netCDF4/_netCDF4.pyx":4523
@@ -50027,7 +49399,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_4__unicode__(struct
*
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4523, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
/* "netCDF4/_netCDF4.pyx":4524
@@ -50037,7 +49409,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_4__unicode__(struct
*
* cdef _def_compound(grp, object dt, object dtype_name):
*/
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4524; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4524, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_self->name);
__Pyx_GIVEREF(__pyx_v_self->name);
@@ -50053,10 +49425,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_4__unicode__(struct
* (self.name,self.dtype)
*
*/
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_name_s_numpy_dtype_s, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_name_s_numpy_dtype_s, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4523, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4523, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -50110,12 +49482,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12CompoundType_8_nc_type___get__(st
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_nc_type(__pyx_v_self->_nc_type); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4476; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_nc_type(__pyx_v_self->_nc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4476, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -50149,11 +49518,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_12CompoundType_8_nc_type_2__set__(struct
int __pyx_r;
__Pyx_RefNannyDeclarations
nc_type __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_nc_type(__pyx_v_value); if (unlikely((__pyx_t_1 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4476; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_nc_type(__pyx_v_value); if (unlikely((__pyx_t_1 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4476, __pyx_L1_error)
__pyx_v_self->_nc_type = __pyx_t_1;
/* function exit code */
@@ -50397,9 +49763,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
nc_type __pyx_t_18;
Py_ssize_t __pyx_t_19;
int __pyx_t_20;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_def_compound", 0);
/* "netCDF4/_netCDF4.pyx":4535
@@ -50409,7 +49772,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* namstring = bytestr
* size = dt.itemsize
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_dtype_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4535; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_dtype_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4535, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
@@ -50421,7 +49784,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* size = dt.itemsize
* ierr = nc_def_compound(grp._grpid, size, namstring, &xtype)
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4536; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 4536, __pyx_L1_error)
__pyx_v_namstring = __pyx_t_2;
/* "netCDF4/_netCDF4.pyx":4537
@@ -50431,9 +49794,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* ierr = nc_def_compound(grp._grpid, size, namstring, &xtype)
* if ierr != NC_NOERR:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4537; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4537, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyInt_As_size_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4537; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_As_size_t(__pyx_t_1); if (unlikely((__pyx_t_3 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4537, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_size = __pyx_t_3;
@@ -50444,9 +49807,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4538; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4538, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4538; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4538, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_ierr = nc_def_compound(__pyx_t_4, __pyx_v_size, __pyx_v_namstring, (&__pyx_v_xtype));
@@ -50468,20 +49831,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* formats = [v[0] for v in dt.fields.values()]
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4540, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4540, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4540, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4540, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4539
* size = dt.itemsize
@@ -50499,9 +49862,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* formats = [v[0] for v in dt.fields.values()]
* offsets = [v[1] for v in dt.fields.values()]
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_fields); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4541; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_fields); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4541, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_keys); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4541; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_keys); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4541, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -50515,14 +49878,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4541; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4541, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4541; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4541, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4541; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4541, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_names = __pyx_t_7;
@@ -50535,11 +49898,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* offsets = [v[1] for v in dt.fields.values()]
* # make sure entries in lists sorted by offset.
*/
- __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_fields); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_fields); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_values); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_values); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -50553,10 +49916,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4542, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
@@ -50564,9 +49927,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__pyx_t_8 = __pyx_t_1; __Pyx_INCREF(__pyx_t_8); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_10 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_8)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4542, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -50574,17 +49937,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
if (likely(PyList_CheckExact(__pyx_t_8))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_8)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_8, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 4542, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_8, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_8, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_8)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_8, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 4542, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_8, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_8, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -50594,7 +49957,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4542, __pyx_L1_error)
}
break;
}
@@ -50602,9 +49965,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
}
__Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_t_1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4542; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_t_1))) __PYX_ERR(0, 4542, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
@@ -50618,11 +49981,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* # make sure entries in lists sorted by offset.
* # (don't know why this is necessary, but it is for version 4.0.1)
*/
- __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_fields); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_fields); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_values); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -50636,10 +49999,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
}
}
if (__pyx_t_1) {
- __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4543, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -50647,9 +50010,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__pyx_t_6 = __pyx_t_8; __Pyx_INCREF(__pyx_t_6); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4543, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
for (;;) {
@@ -50657,17 +50020,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_8 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 4543, __pyx_L1_error)
#else
- __pyx_t_8 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_8); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 4543, __pyx_L1_error)
#else
- __pyx_t_8 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
}
@@ -50677,7 +50040,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4543, __pyx_L1_error)
}
break;
}
@@ -50685,9 +50048,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
}
__Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_8);
__pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_8 = __Pyx_GetItemInt(__pyx_v_v, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_t_8))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_7, (PyObject*)__pyx_t_8))) __PYX_ERR(0, 4543, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -50701,7 +50064,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* formats = _sortbylist(formats, offsets)
* offsets.sort()
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_sortbylist); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_sortbylist); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4546, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -50715,7 +50078,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__pyx_t_9 = 1;
}
}
- __pyx_t_1 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4546, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -50726,7 +50089,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__Pyx_INCREF(__pyx_v_offsets);
__Pyx_GIVEREF(__pyx_v_offsets);
PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_9, __pyx_v_offsets);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4546, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -50740,7 +50103,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* offsets.sort()
* for name, format, offset in zip(names, formats, offsets):
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_sortbylist); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4547; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_sortbylist); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4547, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_1 = NULL;
__pyx_t_9 = 0;
@@ -50754,7 +50117,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__pyx_t_9 = 1;
}
}
- __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4547; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4547, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_1) {
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_1); __pyx_t_1 = NULL;
@@ -50765,7 +50128,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__Pyx_INCREF(__pyx_v_offsets);
__Pyx_GIVEREF(__pyx_v_offsets);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_9, __pyx_v_offsets);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4547; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4547, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -50779,7 +50142,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* for name, format, offset in zip(names, formats, offsets):
* bytestr = _strencode(name)
*/
- __pyx_t_11 = PyList_Sort(__pyx_v_offsets); if (unlikely(__pyx_t_11 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4548; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyList_Sort(__pyx_v_offsets); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 4548, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4549
* formats = _sortbylist(formats, offsets)
@@ -50788,7 +50151,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* bytestr = _strencode(name)
* namstring = bytestr
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -50802,7 +50165,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__pyx_t_9 = 1;
}
}
- __pyx_t_1 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -50816,7 +50179,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__Pyx_INCREF(__pyx_v_offsets);
__Pyx_GIVEREF(__pyx_v_offsets);
PyTuple_SET_ITEM(__pyx_t_1, 2+__pyx_t_9, __pyx_v_offsets);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -50824,9 +50187,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__pyx_t_6 = __pyx_t_7; __Pyx_INCREF(__pyx_t_6); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4549, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -50834,17 +50197,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 4549, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 4549, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -50854,7 +50217,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4549, __pyx_L1_error)
}
break;
}
@@ -50870,7 +50233,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
if (unlikely(size != 3)) {
if (size > 3) __Pyx_RaiseTooManyValuesError(3);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4549, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -50886,17 +50249,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(__pyx_t_12);
#else
- __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
#endif
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_13 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_14 = Py_TYPE(__pyx_t_13)->tp_iternext;
@@ -50906,7 +50269,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__Pyx_GOTREF(__pyx_t_8);
index = 2; __pyx_t_12 = __pyx_t_14(__pyx_t_13); if (unlikely(!__pyx_t_12)) goto __pyx_L10_unpacking_failed;
__Pyx_GOTREF(__pyx_t_12);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_14(__pyx_t_13), 3) < 0) __PYX_ERR(0, 4549, __pyx_L1_error)
__pyx_t_14 = NULL;
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
goto __pyx_L11_unpacking_done;
@@ -50914,10 +50277,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
__pyx_t_14 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4549, __pyx_L1_error)
__pyx_L11_unpacking_done:;
}
- __pyx_t_3 = __Pyx_PyInt_As_size_t(__pyx_t_12); if (unlikely((__pyx_t_3 == (size_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_As_size_t(__pyx_t_12); if (unlikely((__pyx_t_3 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 4549, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1);
__pyx_t_1 = 0;
@@ -50932,7 +50295,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* namstring = bytestr
* if format.kind != 'V': # scalar primitive type
*/
- __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4550; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4550, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF_SET(__pyx_v_bytestr, __pyx_t_7);
__pyx_t_7 = 0;
@@ -50944,7 +50307,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* if format.kind != 'V': # scalar primitive type
* try:
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 4551, __pyx_L1_error)
__pyx_v_namstring = __pyx_t_2;
/* "netCDF4/_netCDF4.pyx":4552
@@ -50954,9 +50317,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* try:
* xtype_tmp = _nptonctype[format.str[1:]]
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_kind); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_kind); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_V, Py_NE)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_V, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4552, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_5) {
@@ -50968,6 +50331,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
@@ -50981,18 +50346,18 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* except KeyError:
* raise ValueError('Unsupported compound type element')
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4554; __pyx_clineno = __LINE__; goto __pyx_L13_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4554, __pyx_L13_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_str); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4554; __pyx_clineno = __LINE__; goto __pyx_L13_error;}
+ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_str); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4554, __pyx_L13_error)
__Pyx_GOTREF(__pyx_t_12);
- __pyx_t_8 = __Pyx_PyObject_GetSlice(__pyx_t_12, 1, 0, NULL, NULL, &__pyx_slice__88, 1, 0, 1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4554; __pyx_clineno = __LINE__; goto __pyx_L13_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetSlice(__pyx_t_12, 1, 0, NULL, NULL, &__pyx_slice__81, 1, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4554, __pyx_L13_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
- __pyx_t_12 = PyObject_GetItem(__pyx_t_7, __pyx_t_8); if (unlikely(__pyx_t_12 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4554; __pyx_clineno = __LINE__; goto __pyx_L13_error;};
+ __pyx_t_12 = PyObject_GetItem(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4554, __pyx_L13_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_18 = __Pyx_PyInt_As_nc_type(__pyx_t_12); if (unlikely((__pyx_t_18 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4554; __pyx_clineno = __LINE__; goto __pyx_L13_error;}
+ __pyx_t_18 = __Pyx_PyInt_As_nc_type(__pyx_t_12); if (unlikely((__pyx_t_18 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4554, __pyx_L13_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__pyx_v_xtype_tmp = __pyx_t_18;
@@ -51009,6 +50374,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
goto __pyx_L20_try_end;
__pyx_L13_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -51022,10 +50388,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* raise ValueError('Unsupported compound type element')
* ierr = nc_insert_compound(grp._grpid, xtype, namstring,
*/
- __pyx_t_4 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_4) {
__Pyx_AddTraceback("netCDF4._netCDF4._def_compound", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_8, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4555; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;}
+ if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_8, &__pyx_t_7) < 0) __PYX_ERR(0, 4555, __pyx_L15_except_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_t_7);
@@ -51037,11 +50403,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* ierr = nc_insert_compound(grp._grpid, xtype, namstring,
* offset, xtype_tmp)
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__89, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4556; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4556, __pyx_L15_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4556; __pyx_clineno = __LINE__; goto __pyx_L15_except_error;}
+ __PYX_ERR(0, 4556, __pyx_L15_except_error)
}
goto __pyx_L15_except_error;
__pyx_L15_except_error:;
@@ -51053,6 +50419,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* xtype_tmp = _nptonctype[format.str[1:]]
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
@@ -51068,9 +50435,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* offset, xtype_tmp)
* if ierr != NC_NOERR:
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4557; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4557, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4557; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4557, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":4558
@@ -51100,20 +50467,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* if format.shape == (): # nested scalar compound type
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4560, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4559
* ierr = nc_insert_compound(grp._grpid, xtype, namstring,
@@ -51142,11 +50509,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* xtype_tmp = _find_cmptype(grp, format)
*/
/*else*/ {
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4562; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4562, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4562; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_RichCompare(__pyx_t_7, __pyx_empty_tuple, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4562, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4562; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4562, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_5) {
@@ -51157,9 +50524,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* bytestr = _strencode(name)
* nested_namstring = bytestr
*/
- __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__find_cmptype(__pyx_v_grp, __pyx_v_format); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4564; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__find_cmptype(__pyx_v_grp, __pyx_v_format); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4564, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_18 = __Pyx_PyInt_As_nc_type(__pyx_t_8); if (unlikely((__pyx_t_18 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4564; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = __Pyx_PyInt_As_nc_type(__pyx_t_8); if (unlikely((__pyx_t_18 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4564, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_v_xtype_tmp = __pyx_t_18;
@@ -51170,7 +50537,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* nested_namstring = bytestr
* ierr = nc_insert_compound(grp._grpid, xtype,\
*/
- __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4565, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF_SET(__pyx_v_bytestr, __pyx_t_8);
__pyx_t_8 = 0;
@@ -51182,7 +50549,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* ierr = nc_insert_compound(grp._grpid, xtype,\
* nested_namstring,\
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4566; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 4566, __pyx_L1_error)
__pyx_v_nested_namstring = __pyx_t_2;
/* "netCDF4/_netCDF4.pyx":4567
@@ -51192,9 +50559,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* nested_namstring,\
* offset, xtype_tmp)
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4567, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4567, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "netCDF4/_netCDF4.pyx":4569
@@ -51224,20 +50591,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* ndims = len(format.shape)
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_8 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4571; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4571, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4571; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4571, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4571; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4571, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4571; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4571, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4570
* nested_namstring,\
@@ -51266,9 +50633,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* for n from 0 <= n < ndims:
*/
/*else*/ {
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4573; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4573, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_19 = PyObject_Length(__pyx_t_8); if (unlikely(__pyx_t_19 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4573; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_19 = PyObject_Length(__pyx_t_8); if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 4573, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_v_ndims = __pyx_t_19;
@@ -51298,12 +50665,12 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* if format.subdtype[0].str[1] != 'V': # primitive type.
* try:
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4576; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_shape); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4576, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4576; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_8, __pyx_v_n, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4576, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4576; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_20 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4576, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
(__pyx_v_dim_sizes[__pyx_v_n]) = __pyx_t_20;
}
@@ -51315,18 +50682,18 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* try:
* xtype_tmp = _nptonctype[format.subdtype[0].str[1:]]
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_subdtype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4577; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_subdtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4577; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_str); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4577; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_str); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_8 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4577; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_7, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_V, Py_NE)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4577; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_t_8, __pyx_n_s_V, Py_NE)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 4577, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_5) {
@@ -51338,6 +50705,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* except KeyError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_17, &__pyx_t_16, &__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_16);
@@ -51351,24 +50720,24 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* except KeyError:
* raise ValueError('Unsupported compound type element')
*/
- __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4579; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_8 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4579, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_subdtype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4579; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_subdtype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4579, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_12 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4579; __pyx_clineno = __LINE__; goto __pyx_L29_error;};
+ __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_7, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4579, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_str); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4579; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_str); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4579, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
- __pyx_t_12 = __Pyx_PyObject_GetSlice(__pyx_t_7, 1, 0, NULL, NULL, &__pyx_slice__90, 1, 0, 1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4579; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_12 = __Pyx_PyObject_GetSlice(__pyx_t_7, 1, 0, NULL, NULL, &__pyx_slice__83, 1, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4579, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = PyObject_GetItem(__pyx_t_8, __pyx_t_12); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4579; __pyx_clineno = __LINE__; goto __pyx_L29_error;};
+ __pyx_t_7 = PyObject_GetItem(__pyx_t_8, __pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4579, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
- __pyx_t_18 = __Pyx_PyInt_As_nc_type(__pyx_t_7); if (unlikely((__pyx_t_18 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4579; __pyx_clineno = __LINE__; goto __pyx_L29_error;}
+ __pyx_t_18 = __Pyx_PyInt_As_nc_type(__pyx_t_7); if (unlikely((__pyx_t_18 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4579, __pyx_L29_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_v_xtype_tmp = __pyx_t_18;
@@ -51385,6 +50754,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
__Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
goto __pyx_L36_try_end;
__pyx_L29_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
@@ -51398,10 +50768,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* raise ValueError('Unsupported compound type element')
* ierr = nc_insert_array_compound(grp._grpid,xtype,namstring,
*/
- __pyx_t_4 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_4) {
__Pyx_AddTraceback("netCDF4._netCDF4._def_compound", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_12, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4580; __pyx_clineno = __LINE__; goto __pyx_L31_except_error;}
+ if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_12, &__pyx_t_8) < 0) __PYX_ERR(0, 4580, __pyx_L31_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GOTREF(__pyx_t_8);
@@ -51413,11 +50783,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* ierr = nc_insert_array_compound(grp._grpid,xtype,namstring,
* offset,xtype_tmp,ndims,dim_sizes)
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__91, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4581; __pyx_clineno = __LINE__; goto __pyx_L31_except_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4581, __pyx_L31_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4581; __pyx_clineno = __LINE__; goto __pyx_L31_except_error;}
+ __PYX_ERR(0, 4581, __pyx_L31_except_error)
}
goto __pyx_L31_except_error;
__pyx_L31_except_error:;
@@ -51429,6 +50799,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* xtype_tmp = _nptonctype[format.subdtype[0].str[1:]]
* except KeyError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_15);
@@ -51444,9 +50815,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* offset,xtype_tmp,ndims,dim_sizes)
* if ierr != NC_NOERR:
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4582; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4582, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4582; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4582, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "netCDF4/_netCDF4.pyx":4583
@@ -51476,20 +50847,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* # find this compound type in this group or it's parents.
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_8 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4585; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4585, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_12 = PyTuple_New(1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4585; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyTuple_New(1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4585, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_INCREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_12, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4585; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4585, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4585; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4585, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4584
* ierr = nc_insert_array_compound(grp._grpid,xtype,namstring,
@@ -51518,15 +50889,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* nested_namstring = bytestr
*/
/*else*/ {
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_subdtype); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4588; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_subdtype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4588, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_12 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4588; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_8, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4588, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__find_cmptype(__pyx_v_grp, __pyx_t_12); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4588; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__find_cmptype(__pyx_v_grp, __pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4588, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
- __pyx_t_18 = __Pyx_PyInt_As_nc_type(__pyx_t_8); if (unlikely((__pyx_t_18 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4588; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = __Pyx_PyInt_As_nc_type(__pyx_t_8); if (unlikely((__pyx_t_18 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4588, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_v_xtype_tmp = __pyx_t_18;
@@ -51537,7 +50908,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* nested_namstring = bytestr
* ierr = nc_insert_array_compound(grp._grpid,xtype,\
*/
- __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_name, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4589, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF_SET(__pyx_v_bytestr, __pyx_t_8);
__pyx_t_8 = 0;
@@ -51549,7 +50920,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* ierr = nc_insert_array_compound(grp._grpid,xtype,\
* nested_namstring,\
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4590; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 4590, __pyx_L1_error)
__pyx_v_nested_namstring = __pyx_t_2;
/* "netCDF4/_netCDF4.pyx":4591
@@ -51559,9 +50930,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* nested_namstring,\
* offset,xtype_tmp,\
*/
- __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4591; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4591; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4591, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "netCDF4/_netCDF4.pyx":4594
@@ -51591,20 +50962,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* return xtype
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_8 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4596; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4596, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- __pyx_t_12 = PyTuple_New(1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4596; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyTuple_New(1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4596, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_INCREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_12, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4596; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4596, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4596; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4596, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4595
* offset,xtype_tmp,\
@@ -51648,7 +51019,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_compound(PyObject *__pyx_v_grp,
* cdef _find_cmptype(grp, dtype):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_6 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4598; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4598, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_r = __pyx_t_6;
__pyx_t_6 = 0;
@@ -51723,9 +51094,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
int __pyx_t_17;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_find_cmptype", 0);
/* "netCDF4/_netCDF4.pyx":4604
@@ -51744,9 +51112,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* xtype = cmpdt._nc_type
* names1 = dtype.names; names2 = cmpdt.dtype.names
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_cmptypes); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_cmptypes); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -51760,10 +51128,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
}
}
if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4605, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -51771,9 +51139,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
__pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4605, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -51781,17 +51149,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 4605, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 4605, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -51801,7 +51169,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4605, __pyx_L1_error)
}
break;
}
@@ -51817,7 +51185,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4605, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -51830,15 +51198,15 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
#else
- __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
@@ -51846,7 +51214,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
__Pyx_GOTREF(__pyx_t_2);
index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 4605, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L6_unpacking_done;
@@ -51854,7 +51222,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4605; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4605, __pyx_L1_error)
__pyx_L6_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_cmpname, __pyx_t_2);
@@ -51869,9 +51237,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* names1 = dtype.names; names2 = cmpdt.dtype.names
* formats1 = [v[0] for v in dtype.fields.values()]
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cmpdt, __pyx_n_s_nc_type); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4606; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cmpdt, __pyx_n_s_nc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4606, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyInt_As_nc_type(__pyx_t_1); if (unlikely((__pyx_t_9 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4606; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_nc_type(__pyx_t_1); if (unlikely((__pyx_t_9 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4606, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_xtype = __pyx_t_9;
@@ -51882,13 +51250,13 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* formats1 = [v[0] for v in dtype.fields.values()]
* formats2 = [v[0] for v in cmpdt.dtype.fields.values()]
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_names); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4607, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_names1, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cmpdt, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cmpdt, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4607, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_names); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_names); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4607, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_names2, __pyx_t_6);
@@ -51901,11 +51269,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* formats2 = [v[0] for v in cmpdt.dtype.fields.values()]
* # match names, formats, but not offsets (they may be changed
*/
- __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_fields); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dtype, __pyx_n_s_fields); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_values); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_values); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -51919,10 +51287,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
}
}
if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4608, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -51930,9 +51298,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
__pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7); __pyx_t_10 = 0;
__pyx_t_11 = NULL;
} else {
- __pyx_t_10 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_11 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4608, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -51940,17 +51308,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_10); __Pyx_INCREF(__pyx_t_1); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_10); __Pyx_INCREF(__pyx_t_1); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 4608, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_10); __Pyx_INCREF(__pyx_t_1); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_10); __Pyx_INCREF(__pyx_t_1); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 4608, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -51960,7 +51328,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4608, __pyx_L1_error)
}
break;
}
@@ -51968,9 +51336,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
}
__Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_1))) __PYX_ERR(0, 4608, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -51984,14 +51352,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* # match names, formats, but not offsets (they may be changed
* # by netcdf lib).
*/
- __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cmpdt, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cmpdt, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_fields); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_fields); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_values); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_values); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -52005,10 +51373,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
}
}
if (__pyx_t_2) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4609, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -52016,9 +51384,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
__pyx_t_1 = __pyx_t_7; __Pyx_INCREF(__pyx_t_1); __pyx_t_10 = 0;
__pyx_t_11 = NULL;
} else {
- __pyx_t_10 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_11 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4609, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -52026,17 +51394,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 4609, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_10); __Pyx_INCREF(__pyx_t_7); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 4609, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -52046,7 +51414,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4609, __pyx_L1_error)
}
break;
}
@@ -52054,9 +51422,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
}
__Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_7);
__pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_v, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_7))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_6, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 4609, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -52070,16 +51438,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* match = True
* break
*/
- __pyx_t_6 = PyObject_RichCompare(__pyx_v_names1, __pyx_v_names2, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_13 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_RichCompare(__pyx_v_names1, __pyx_v_names2, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4612, __pyx_L1_error)
+ __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 4612, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_13) {
} else {
__pyx_t_12 = __pyx_t_13;
goto __pyx_L12_bool_binop_done;
}
- __pyx_t_6 = PyObject_RichCompare(__pyx_v_formats1, __pyx_v_formats2, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_13 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_RichCompare(__pyx_v_formats1, __pyx_v_formats2, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4612, __pyx_L1_error)
+ __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_13 < 0)) __PYX_ERR(0, 4612, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_12 = __pyx_t_13;
__pyx_L12_bool_binop_done:;
@@ -52141,6 +51509,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* except AttributeError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_15);
@@ -52154,7 +51524,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* except AttributeError:
* raise ValueError("cannot find compound type in this group or parent groups")
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_parent); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4617; __pyx_clineno = __LINE__; goto __pyx_L15_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_parent); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4617, __pyx_L15_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_parent_grp = __pyx_t_3;
__pyx_t_3 = 0;
@@ -52172,6 +51542,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
goto __pyx_L22_try_end;
__pyx_L15_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -52185,10 +51556,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* raise ValueError("cannot find compound type in this group or parent groups")
* if parent_grp is None:
*/
- __pyx_t_17 = PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
+ __pyx_t_17 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
if (__pyx_t_17) {
__Pyx_AddTraceback("netCDF4._netCDF4._find_cmptype", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_6, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4618; __pyx_clineno = __LINE__; goto __pyx_L17_except_error;}
+ if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_6, &__pyx_t_1) < 0) __PYX_ERR(0, 4618, __pyx_L17_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_1);
@@ -52200,11 +51571,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* if parent_grp is None:
* raise ValueError("cannot find compound type in this group or parent groups")
*/
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__92, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4619; __pyx_clineno = __LINE__; goto __pyx_L17_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4619, __pyx_L17_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4619; __pyx_clineno = __LINE__; goto __pyx_L17_except_error;}
+ __PYX_ERR(0, 4619, __pyx_L17_except_error)
}
goto __pyx_L17_except_error;
__pyx_L17_except_error:;
@@ -52216,6 +51587,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* parent_grp = grp.parent
* except AttributeError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
@@ -52242,11 +51614,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* else:
* xtype = _find_cmptype(parent_grp,dtype)
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__93, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4621; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__86, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4621, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4621; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4621, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4620
* except AttributeError:
@@ -52265,9 +51637,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
*
*/
/*else*/ {
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__find_cmptype(__pyx_v_parent_grp, __pyx_v_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__find_cmptype(__pyx_v_parent_grp, __pyx_v_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4623, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = __Pyx_PyInt_As_nc_type(__pyx_t_1); if (unlikely((__pyx_t_9 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_nc_type(__pyx_t_1); if (unlikely((__pyx_t_9 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4623, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_xtype = __pyx_t_9;
}
@@ -52289,7 +51661,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__find_cmptype(PyObject *__pyx_v_grp,
* cdef _read_compound(group, nc_type xtype, endian=None):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4624; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4624, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -52376,9 +51748,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
PyObject *__pyx_t_15 = NULL;
int __pyx_t_16;
struct __pyx_opt_args_7netCDF4_8_netCDF4__read_compound __pyx_t_17;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_read_compound", 0);
if (__pyx_optional_args) {
if (__pyx_optional_args->__pyx_n > 0) {
@@ -52393,9 +51762,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* with nogil:
* ierr = nc_inq_compound(_grpid, xtype, cmp_namstring, NULL, &nfields)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4639; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4639, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4639; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4639, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
@@ -52459,20 +51828,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* # loop over fields.
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4643, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4643, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4643, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4643, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4642
* with nogil:
@@ -52490,14 +51859,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* # loop over fields.
* names = []
*/
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_cmp_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_cmp_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -52511,7 +51880,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -52522,7 +51891,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -52536,7 +51905,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* formats = []
* offsets = []
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4646; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4646, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_names = __pyx_t_1;
__pyx_t_1 = 0;
@@ -52548,7 +51917,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* offsets = []
* for nf from 0 <= nf < nfields:
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4647; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4647, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_formats = __pyx_t_1;
__pyx_t_1 = 0;
@@ -52560,7 +51929,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* for nf from 0 <= nf < nfields:
* with nogil:
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4648; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4648, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_offsets = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
@@ -52635,20 +52004,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* with nogil:
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4660, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4659
* &numdims,
@@ -52728,20 +52097,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* names.append(field_name)
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4672; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4672; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4672; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4672; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4672, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4671
* &numdims,
@@ -52759,14 +52128,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* names.append(field_name)
* offsets.append(offset)
*/
- __pyx_t_6 = __Pyx_PyObject_FromString(__pyx_v_field_namstring); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_FromString(__pyx_v_field_namstring); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_5 = NULL;
__pyx_t_9 = 0;
@@ -52780,7 +52149,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__pyx_t_9 = 1;
}
}
- __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
@@ -52791,7 +52160,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_6 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4673; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
@@ -52805,7 +52174,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* offsets.append(offset)
* # if numdims=0, not an array.
*/
- __pyx_t_12 = __Pyx_PyObject_Append(__pyx_v_names, __pyx_v_field_name); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_Append(__pyx_v_names, __pyx_v_field_name); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 4674, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4675
* field_name = field_namstring.decode(default_encoding,unicode_error)
@@ -52814,9 +52183,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* # if numdims=0, not an array.
* field_shape = ()
*/
- __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_offset); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_FromSize_t(__pyx_v_offset); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4675, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_offsets, __pyx_t_1); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4675; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_offsets, __pyx_t_1); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 4675, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":4677
@@ -52856,14 +52225,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* free(dim_sizes)
* # check to see if this field is a nested compound type.
*/
- __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_dim_sizes[__pyx_v_ndim])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int((__pyx_v_dim_sizes[__pyx_v_ndim])); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4680, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4680, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_Add(__pyx_v_field_shape, __pyx_t_10); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4680; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_v_field_shape, __pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4680, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF_SET(__pyx_v_field_shape, __pyx_t_1);
@@ -52896,6 +52265,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* if endian is not None:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_14);
@@ -52909,9 +52280,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* if endian is not None:
* format = endian + format
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4684; __pyx_clineno = __LINE__; goto __pyx_L24_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4684, __pyx_L24_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_field_typeid, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(__pyx_t_10 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4684; __pyx_clineno = __LINE__; goto __pyx_L24_error;};
+ __pyx_t_10 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_field_typeid, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4684, __pyx_L24_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_field_type, __pyx_t_10);
@@ -52935,8 +52306,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* except KeyError:
* with nogil:
*/
- if (unlikely(!__pyx_v_format)) { __Pyx_RaiseUnboundLocalError("format"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4686; __pyx_clineno = __LINE__; goto __pyx_L24_error;} }
- __pyx_t_10 = PyNumber_Add(__pyx_v_endian, __pyx_v_format); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4686; __pyx_clineno = __LINE__; goto __pyx_L24_error;}
+ if (unlikely(!__pyx_v_format)) { __Pyx_RaiseUnboundLocalError("format"); __PYX_ERR(0, 4686, __pyx_L24_error) }
+ __pyx_t_10 = PyNumber_Add(__pyx_v_endian, __pyx_v_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4686, __pyx_L24_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_XDECREF_SET(__pyx_v_format, __pyx_t_10);
__pyx_t_10 = 0;
@@ -52963,6 +52334,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
goto __pyx_L31_try_end;
__pyx_L24_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -52977,10 +52349,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* with nogil:
* ierr = nc_inq_user_type(_grpid,
*/
- __pyx_t_2 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_2) {
__Pyx_AddTraceback("netCDF4._netCDF4._read_compound", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_1, &__pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4687; __pyx_clineno = __LINE__; goto __pyx_L26_except_error;}
+ if (__Pyx_GetException(&__pyx_t_10, &__pyx_t_1, &__pyx_t_8) < 0) __PYX_ERR(0, 4687, __pyx_L26_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_8);
@@ -53046,7 +52418,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
*/
__pyx_t_17.__pyx_n = 1;
__pyx_t_17.endian = __pyx_v_endian;
- __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__read_compound(__pyx_v_group, __pyx_v_field_typeid, &__pyx_t_17); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4693; __pyx_clineno = __LINE__; goto __pyx_L26_except_error;}
+ __pyx_t_7 = __pyx_f_7netCDF4_8_netCDF4__read_compound(__pyx_v_group, __pyx_v_field_typeid, &__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4693, __pyx_L26_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_XDECREF_SET(__pyx_v_field_type, __pyx_t_7);
__pyx_t_7 = 0;
@@ -53069,11 +52441,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* formats.append((field_type,field_shape))
*/
/*else*/ {
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__94, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4695; __pyx_clineno = __LINE__; goto __pyx_L26_except_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__87, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4695, __pyx_L26_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4695; __pyx_clineno = __LINE__; goto __pyx_L26_except_error;}
+ __PYX_ERR(0, 4695, __pyx_L26_except_error)
}
__pyx_L40:;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
@@ -53091,12 +52463,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* field_type = _nctonptype[field_typeid]
* if endian is not None:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
goto __pyx_L1_error;
__pyx_L25_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
@@ -53111,8 +52485,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* formats.append((field_type,field_shape))
* else:
*/
- __pyx_t_8 = PyObject_RichCompare(__pyx_v_field_shape, __pyx_empty_tuple, Py_NE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4696; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_16 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4696; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_RichCompare(__pyx_v_field_shape, __pyx_empty_tuple, Py_NE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4696, __pyx_L1_error)
+ __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 4696, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_16) {
@@ -53123,7 +52497,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* else:
* formats.append(field_type)
*/
- __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4697; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4697, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_v_field_type);
__Pyx_GIVEREF(__pyx_v_field_type);
@@ -53131,7 +52505,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__Pyx_INCREF(__pyx_v_field_shape);
__Pyx_GIVEREF(__pyx_v_field_shape);
PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_field_shape);
- __pyx_t_12 = __Pyx_PyObject_Append(__pyx_v_formats, __pyx_t_8); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4697; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_Append(__pyx_v_formats, __pyx_t_8); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 4697, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "netCDF4/_netCDF4.pyx":4696
@@ -53152,7 +52526,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* names = _sortbylist(names, offsets)
*/
/*else*/ {
- __pyx_t_12 = __Pyx_PyObject_Append(__pyx_v_formats, __pyx_v_field_type); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4699; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_Append(__pyx_v_formats, __pyx_v_field_type); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 4699, __pyx_L1_error)
}
__pyx_L41:;
}
@@ -53164,7 +52538,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* formats = _sortbylist(formats, offsets)
* offsets.sort()
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sortbylist); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4701; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sortbylist); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4701, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_10 = NULL;
__pyx_t_9 = 0;
@@ -53178,7 +52552,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__pyx_t_9 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4701; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4701, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_10) {
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_10); __pyx_t_10 = NULL;
@@ -53189,7 +52563,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__Pyx_INCREF(__pyx_v_offsets);
__Pyx_GIVEREF(__pyx_v_offsets);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_9, __pyx_v_offsets);
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4701; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4701, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -53203,7 +52577,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* offsets.sort()
* # create a dict that can be converted into a numpy dtype.
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sortbylist); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sortbylist); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_7 = NULL;
__pyx_t_9 = 0;
@@ -53217,7 +52591,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -53228,7 +52602,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__Pyx_INCREF(__pyx_v_offsets);
__Pyx_GIVEREF(__pyx_v_offsets);
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_v_offsets);
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -53242,7 +52616,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* # create a dict that can be converted into a numpy dtype.
* dtype_dict = {'names':names,'formats':formats,'offsets':offsets}
*/
- __pyx_t_12 = PyList_Sort(__pyx_v_offsets); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4703; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyList_Sort(__pyx_v_offsets); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 4703, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4705
* offsets.sort()
@@ -53251,11 +52625,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* return CompoundType(group, dtype_dict, name, typeid=xtype)
*
*/
- __pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4705; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4705, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_names, __pyx_v_names) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4705; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_formats, __pyx_v_formats) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4705; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_offsets, __pyx_v_offsets) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4705; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_names, __pyx_v_names) < 0) __PYX_ERR(0, 4705, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_formats, __pyx_v_formats) < 0) __PYX_ERR(0, 4705, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_offsets, __pyx_v_offsets) < 0) __PYX_ERR(0, 4705, __pyx_L1_error)
__pyx_v_dtype_dict = ((PyObject*)__pyx_t_8);
__pyx_t_8 = 0;
@@ -53267,7 +52641,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
* # VLEN datatype support.
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4706; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4706, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -53278,13 +52652,13 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_compound(PyObject *__pyx_v_gro
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_v_name);
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4706; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4706, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4706; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4706, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_typeid, __pyx_t_10) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4706; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_typeid, __pyx_t_10) < 0) __PYX_ERR(0, 4706, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_CompoundType), __pyx_t_8, __pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4706; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_CompoundType), __pyx_t_8, __pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4706, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -53344,9 +52718,6 @@ static int __pyx_pw_7netCDF4_8_netCDF4_6VLType_1__init__(PyObject *__pyx_v_self,
PyObject *__pyx_v_dt = 0;
PyObject *__pyx_v_dtype_name = 0;
PyObject *__pyx_v_kwargs = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -53373,16 +52744,16 @@ static int __pyx_pw_7netCDF4_8_netCDF4_6VLType_1__init__(PyObject *__pyx_v_self,
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dt)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4726; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(0, 4726, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dtype_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4726; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(0, 4726, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4726; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 4726, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
@@ -53397,7 +52768,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_6VLType_1__init__(PyObject *__pyx_v_self,
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4726; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4726, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("netCDF4._netCDF4.VLType.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
@@ -53424,9 +52795,6 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *(*__pyx_t_8)(PyObject *);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
__Pyx_INCREF(__pyx_v_dt);
@@ -53437,7 +52805,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
* xtype = kwargs['typeid']
* else:
*/
- __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_typeid, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4745; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_typeid, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 4745, __pyx_L1_error)
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
@@ -53448,9 +52816,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
* else:
* xtype, dt = _def_vlen(grp, dt, dtype_name)
*/
- __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_typeid); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4746; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_typeid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4746, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyInt_As_nc_type(__pyx_t_3); if (unlikely((__pyx_t_4 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4746; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_nc_type(__pyx_t_3); if (unlikely((__pyx_t_4 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4746, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_xtype = __pyx_t_4;
@@ -53472,7 +52840,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
* self.dtype = dt
*/
/*else*/ {
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__def_vlen(__pyx_v_grp, __pyx_v_dt, __pyx_v_dtype_name); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__def_vlen(__pyx_v_grp, __pyx_v_dt, __pyx_v_dtype_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
PyObject* sequence = __pyx_t_3;
@@ -53484,7 +52852,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4748, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -53497,15 +52865,15 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
#else
- __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_7 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
@@ -53513,7 +52881,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
__Pyx_GOTREF(__pyx_t_5);
index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L4_unpacking_failed;
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 4748, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L5_unpacking_done;
@@ -53521,10 +52889,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4748, __pyx_L1_error)
__pyx_L5_unpacking_done:;
}
- __pyx_t_4 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_4 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4748; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_4 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4748, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_xtype = __pyx_t_4;
__Pyx_DECREF_SET(__pyx_v_dt, __pyx_t_6);
@@ -53561,8 +52929,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType___init__(struct __pyx_obj_7netCDF
* self.name = None
* else:
*/
- __pyx_t_3 = PyObject_RichCompare(__pyx_v_dt, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4751; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_dt, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4751, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4751, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_2) {
@@ -53659,9 +53027,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_2__repr__(struct __pyx_obj_
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
/* "netCDF4/_netCDF4.pyx":4757
@@ -53671,9 +53036,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_2__repr__(struct __pyx_obj_
* return self.__unicode__()
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4757; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4757, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4757; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4757, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
@@ -53685,7 +53050,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_2__repr__(struct __pyx_obj_
* return unicode(self).encode(default_encoding)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4758, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -53698,10 +53063,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_2__repr__(struct __pyx_obj_
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4758, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4758, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -53727,18 +53092,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_2__repr__(struct __pyx_obj_
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4760; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4760; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4760; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4760; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -53751,17 +53116,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_2__repr__(struct __pyx_obj_
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4760; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4760, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4760; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4760; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -53822,9 +53187,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_4__unicode__(struct __pyx_o
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__unicode__", 0);
/* "netCDF4/_netCDF4.pyx":4763
@@ -53834,8 +53196,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_4__unicode__(struct __pyx_o
* return repr(type(self))+': string type'
* else:
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4763; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4763; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_v_self->dtype, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4763, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4763, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
@@ -53847,9 +53209,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_4__unicode__(struct __pyx_o
* return repr(type(self))+": name = '%s', numpy dtype = %s\n" %\
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4764; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_string_type); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4764; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_kp_s_string_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_3;
@@ -53874,7 +53236,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_4__unicode__(struct __pyx_o
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4766; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "netCDF4/_netCDF4.pyx":4767
@@ -53884,7 +53246,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_4__unicode__(struct __pyx_o
*
* cdef _def_vlen(grp, object dt, object dtype_name):
*/
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4767; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4767, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_self->name);
__Pyx_GIVEREF(__pyx_v_self->name);
@@ -53900,10 +53262,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_4__unicode__(struct __pyx_o
* (self.name, self.dtype)
*
*/
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_name_s_numpy_dtype_s, __pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4766; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_name_s_numpy_dtype_s, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4766; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4766, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -53958,12 +53320,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6VLType_8_nc_type___get__(struct __
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_nc_type(__pyx_v_self->_nc_type); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_nc_type(__pyx_v_self->_nc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4720, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -53997,11 +53356,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_6VLType_8_nc_type_2__set__(struct __pyx_o
int __pyx_r;
__Pyx_RefNannyDeclarations
nc_type __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_nc_type(__pyx_v_value); if (unlikely((__pyx_t_1 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4720; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_nc_type(__pyx_v_value); if (unlikely((__pyx_t_1 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4720, __pyx_L1_error)
__pyx_v_self->_nc_type = __pyx_t_1;
/* function exit code */
@@ -54222,9 +53578,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
int __pyx_t_7;
nc_type __pyx_t_8;
int __pyx_t_9;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_def_vlen", 0);
__Pyx_INCREF(__pyx_v_dt);
@@ -54235,8 +53588,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* xtype = NC_STRING
* # dtype_name ignored
*/
- __pyx_t_1 = PyObject_RichCompare(__pyx_v_dt, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4777; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4777; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_v_dt, ((PyObject *)(&PyString_Type)), Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4777, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4777, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
@@ -54267,7 +53620,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* dt = numpy.dtype(dt) # convert to numpy datatype.
*/
/*else*/ {
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_dtype_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4781; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_dtype_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4781, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
@@ -54279,7 +53632,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* dt = numpy.dtype(dt) # convert to numpy datatype.
* if dt.str[1:] in _supportedtypes:
*/
- __pyx_t_3 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4782; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_3) && PyErr_Occurred())) __PYX_ERR(0, 4782, __pyx_L1_error)
__pyx_v_namstring = __pyx_t_3;
/* "netCDF4/_netCDF4.pyx":4783
@@ -54289,9 +53642,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* if dt.str[1:] in _supportedtypes:
* # find netCDF primitive data type corresponding to
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4783; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4783; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -54305,16 +53658,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
}
}
if (!__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_dt); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4783; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_dt); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4783; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_dt);
__Pyx_GIVEREF(__pyx_v_dt);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_dt);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4783; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -54329,14 +53682,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* # find netCDF primitive data type corresponding to
* # specified numpy data type.
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_str); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4784; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_str); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4784, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_t_1, 1, 0, NULL, NULL, &__pyx_slice__95, 1, 0, 1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4784; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetSlice(__pyx_t_1, 1, 0, NULL, NULL, &__pyx_slice__88, 1, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4784, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4784; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_supportedtypes); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4784, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_t_1, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4784; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_5, __pyx_t_1, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4784, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_7 = (__pyx_t_2 != 0);
@@ -54349,18 +53702,18 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* ierr = nc_def_vlen(grp._grpid, namstring, xtype_tmp, &xtype);
* if ierr != NC_NOERR:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4787, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_str); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4787, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__96, 1, 0, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetSlice(__pyx_t_5, 1, 0, NULL, NULL, &__pyx_slice__89, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4787, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyObject_GetItem(__pyx_t_1, __pyx_t_6); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4787; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = PyObject_GetItem(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4787, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_8 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_8 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_8 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4787, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_xtype_tmp = __pyx_t_8;
@@ -54371,9 +53724,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4788; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4788, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4788; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4788, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_ierr = nc_def_vlen(__pyx_t_9, __pyx_v_namstring, __pyx_v_xtype_tmp, (&__pyx_v_xtype));
@@ -54395,20 +53748,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* raise KeyError("unsupported datatype specified for VLEN")
*/
__pyx_t_3 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_5 = __Pyx_decode_c_string(__pyx_t_3, 0, strlen(__pyx_t_3), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4790; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_decode_c_string(__pyx_t_3, 0, strlen(__pyx_t_3), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4790, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4790; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4790, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4790; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4790, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4790; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4790, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4789
* xtype_tmp = _nptonctype[dt.str[1:]]
@@ -54437,11 +53790,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
*
*/
/*else*/ {
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4792; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4792, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4792; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4792, __pyx_L1_error)
}
__pyx_L4:;
}
@@ -54455,9 +53808,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_vlen(PyObject *__pyx_v_grp, PyO
* cdef _read_vlen(group, nc_type xtype, endian=None):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_5 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4793, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4793, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
@@ -54527,9 +53880,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
int __pyx_t_14;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_read_vlen", 0);
if (__pyx_optional_args) {
if (__pyx_optional_args->__pyx_n > 0) {
@@ -54544,9 +53894,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* if xtype == NC_STRING:
* dt = str
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4804; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4804, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4804; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4804, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
@@ -54651,20 +54001,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* try:
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4812; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4812, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4812; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4812, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4812; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4812, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4812; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4812, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4811
* with nogil:
@@ -54682,14 +54032,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* try:
* datatype = _nctonptype[base_xtype]
*/
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_vl_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_vl_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -54703,7 +54053,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -54714,7 +54064,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -54729,6 +54079,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* if endian is not None: datatype = endian + datatype
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
@@ -54742,9 +54094,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* if endian is not None: datatype = endian + datatype
* dt = numpy.dtype(datatype) # see if it is a primitive type
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4815; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4815, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_base_xtype, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4815; __pyx_clineno = __LINE__; goto __pyx_L8_error;};
+ __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_base_xtype, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4815, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_datatype = __pyx_t_6;
@@ -54760,7 +54112,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
__pyx_t_3 = (__pyx_v_endian != Py_None);
__pyx_t_14 = (__pyx_t_3 != 0);
if (__pyx_t_14) {
- __pyx_t_6 = PyNumber_Add(__pyx_v_endian, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4816; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_6 = PyNumber_Add(__pyx_v_endian, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4816, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF_SET(__pyx_v_datatype, __pyx_t_6);
__pyx_t_6 = 0;
@@ -54773,9 +54125,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* except KeyError:
* raise KeyError("unsupported component type for VLEN")
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4817; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4817, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4817; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4817, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -54789,16 +54141,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
}
}
if (!__pyx_t_1) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4817; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4817, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_6);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4817; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4817, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_INCREF(__pyx_v_datatype);
__Pyx_GIVEREF(__pyx_v_datatype);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_datatype);
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4817; __pyx_clineno = __LINE__; goto __pyx_L8_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4817, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -54819,6 +54171,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
goto __pyx_L15_try_end;
__pyx_L8_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -54833,10 +54186,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* raise KeyError("unsupported component type for VLEN")
* return VLType(group, dt, name, typeid=xtype)
*/
- __pyx_t_2 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_2) {
__Pyx_AddTraceback("netCDF4._netCDF4._read_vlen", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_10, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4818; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;}
+ if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_10, &__pyx_t_7) < 0) __PYX_ERR(0, 4818, __pyx_L10_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_t_7);
@@ -54848,11 +54201,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* return VLType(group, dt, name, typeid=xtype)
*
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__98, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4819; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__91, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4819, __pyx_L10_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4819; __pyx_clineno = __LINE__; goto __pyx_L10_except_error;}
+ __PYX_ERR(0, 4819, __pyx_L10_except_error)
}
goto __pyx_L10_except_error;
__pyx_L10_except_error:;
@@ -54864,6 +54217,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* datatype = _nctonptype[base_xtype]
* if endian is not None: datatype = endian + datatype
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
@@ -54882,7 +54236,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
* # Enum datatype support.
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4820; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4820, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -54893,13 +54247,13 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_vlen(PyObject *__pyx_v_group,
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_name);
- __pyx_t_10 = PyDict_New(); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4820; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyDict_New(); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4820, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_6 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4820; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4820, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_typeid, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4820; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_typeid, __pyx_t_6) < 0) __PYX_ERR(0, 4820, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_VLType), __pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4820; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_VLType), __pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4820, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
@@ -54954,9 +54308,6 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8EnumType_1__init__(PyObject *__pyx_v_sel
PyObject *__pyx_v_dtype_name = 0;
PyObject *__pyx_v_enum_dict = 0;
PyObject *__pyx_v_kwargs = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -54984,21 +54335,21 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8EnumType_1__init__(PyObject *__pyx_v_sel
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dt)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4842; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 1); __PYX_ERR(0, 4842, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dtype_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4842; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 2); __PYX_ERR(0, 4842, __pyx_L3_error)
}
case 3:
if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_enum_dict)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4842; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, 3); __PYX_ERR(0, 4842, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4842; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 4842, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
goto __pyx_L5_argtuple_error;
@@ -55015,7 +54366,7 @@ static int __pyx_pw_7netCDF4_8_netCDF4_8EnumType_1__init__(PyObject *__pyx_v_sel
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4842; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 4842, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("netCDF4._netCDF4.EnumType.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
@@ -55042,9 +54393,6 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType___init__(struct __pyx_obj_7netC
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *(*__pyx_t_8)(PyObject *);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
__Pyx_INCREF(__pyx_v_dt);
@@ -55055,7 +54403,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType___init__(struct __pyx_obj_7netC
* xtype = kwargs['typeid']
* else:
*/
- __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_typeid, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_typeid, __pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 4864, __pyx_L1_error)
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
@@ -55066,9 +54414,9 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType___init__(struct __pyx_obj_7netC
* else:
* xtype, dt = _def_enum(grp, dt, dtype_name, enum_dict)
*/
- __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_typeid); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4865; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_kwargs, __pyx_n_s_typeid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4865, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyInt_As_nc_type(__pyx_t_3); if (unlikely((__pyx_t_4 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4865; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_nc_type(__pyx_t_3); if (unlikely((__pyx_t_4 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4865, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_xtype = __pyx_t_4;
@@ -55090,7 +54438,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType___init__(struct __pyx_obj_7netC
* self.dtype = dt
*/
/*else*/ {
- __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__def_enum(__pyx_v_grp, __pyx_v_dt, __pyx_v_dtype_name, __pyx_v_enum_dict); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __pyx_f_7netCDF4_8_netCDF4__def_enum(__pyx_v_grp, __pyx_v_dt, __pyx_v_dtype_name, __pyx_v_enum_dict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4867, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
PyObject* sequence = __pyx_t_3;
@@ -55102,7 +54450,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType___init__(struct __pyx_obj_7netC
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4867, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -55115,15 +54463,15 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType___init__(struct __pyx_obj_7netC
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
#else
- __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4867, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4867, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_7 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4867, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
@@ -55131,7 +54479,7 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType___init__(struct __pyx_obj_7netC
__Pyx_GOTREF(__pyx_t_5);
index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L4_unpacking_failed;
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 4867, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L5_unpacking_done;
@@ -55139,10 +54487,10 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType___init__(struct __pyx_obj_7netC
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4867, __pyx_L1_error)
__pyx_L5_unpacking_done:;
}
- __pyx_t_4 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_4 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4867; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_As_nc_type(__pyx_t_5); if (unlikely((__pyx_t_4 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4867, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_xtype = __pyx_t_4;
__Pyx_DECREF_SET(__pyx_v_dt, __pyx_t_6);
@@ -55252,9 +54600,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_2__repr__(struct __pyx_ob
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
/* "netCDF4/_netCDF4.pyx":4874
@@ -55264,9 +54609,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_2__repr__(struct __pyx_ob
* return self.__unicode__()
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4874; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4874, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4874; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4874, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
@@ -55278,7 +54623,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_2__repr__(struct __pyx_ob
* return unicode(self).encode(default_encoding)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4875, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -55291,10 +54636,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_2__repr__(struct __pyx_ob
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4875, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4875; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4875, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -55320,18 +54665,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_2__repr__(struct __pyx_ob
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4877; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4877, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self));
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4877; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4877, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4877; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4877, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4877; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4877, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -55344,17 +54689,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_2__repr__(struct __pyx_ob
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4877; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4877, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4877; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4877, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4877; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4877, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -55414,9 +54759,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_4__unicode__(struct __pyx
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__unicode__", 0);
/* "netCDF4/_netCDF4.pyx":4880
@@ -55427,7 +54769,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_4__unicode__(struct __pyx
* (self.name, self.dtype, self.enum_dict)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4880; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_Repr(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4880, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
/* "netCDF4/_netCDF4.pyx":4882
@@ -55437,7 +54779,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_4__unicode__(struct __pyx
*
* cdef _def_enum(grp, object dt, object dtype_name, object enum_dict):
*/
- __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4882; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4882, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_self->name);
__Pyx_GIVEREF(__pyx_v_self->name);
@@ -55456,7 +54798,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_4__unicode__(struct __pyx
* (self.name, self.dtype, self.enum_dict)
*
*/
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_name_s_numpy_dtype_s_fields_val, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4881; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_name_s_numpy_dtype_s_fields_val, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4881, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -55467,7 +54809,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_4__unicode__(struct __pyx
* ": name = '%s', numpy dtype = %s, fields/values =%s\n" %\
* (self.name, self.dtype, self.enum_dict)
*/
- __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4880; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4880, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -55521,12 +54863,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8EnumType_8_nc_type___get__(struct
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyInt_From_nc_type(__pyx_v_self->_nc_type); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4834; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_nc_type(__pyx_v_self->_nc_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4834, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -55560,11 +54899,8 @@ static int __pyx_pf_7netCDF4_8_netCDF4_8EnumType_8_nc_type_2__set__(struct __pyx
int __pyx_r;
__Pyx_RefNannyDeclarations
nc_type __pyx_t_1;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__set__", 0);
- __pyx_t_1 = __Pyx_PyInt_As_nc_type(__pyx_v_value); if (unlikely((__pyx_t_1 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4834; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_As_nc_type(__pyx_v_value); if (unlikely((__pyx_t_1 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4834, __pyx_L1_error)
__pyx_v_self->_nc_type = __pyx_t_1;
/* function exit code */
@@ -55878,9 +55214,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
int __pyx_t_9;
Py_ssize_t __pyx_t_10;
PyObject *(*__pyx_t_11)(PyObject *);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_def_enum", 0);
__Pyx_INCREF(__pyx_v_dt);
@@ -55891,7 +55224,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* namstring = bytestr
* dt = numpy.dtype(dt) # convert to numpy datatype.
*/
- __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_dtype_name, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4890; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_dtype_name, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4890, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_bytestr = __pyx_t_1;
__pyx_t_1 = 0;
@@ -55903,7 +55236,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* dt = numpy.dtype(dt) # convert to numpy datatype.
* if dt.str[1:] in _intnptonctype.keys():
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4891; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 4891, __pyx_L1_error)
__pyx_v_namstring = __pyx_t_2;
/* "netCDF4/_netCDF4.pyx":4892
@@ -55913,9 +55246,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* if dt.str[1:] in _intnptonctype.keys():
* # find netCDF primitive data type corresponding to
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4892, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4892, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -55929,16 +55262,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_dt); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_dt); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4892, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4892, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_dt);
__Pyx_GIVEREF(__pyx_v_dt);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_dt);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4892; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4892, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
@@ -55953,14 +55286,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* # find netCDF primitive data type corresponding to
* # specified numpy data type.
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_str); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_str); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4893, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_t_1, 1, 0, NULL, NULL, &__pyx_slice__99, 1, 0, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_t_1, 1, 0, NULL, NULL, &__pyx_slice__92, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4893, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_intnptonctype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_intnptonctype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4893, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4893, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = NULL;
@@ -55974,14 +55307,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4893, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4893, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_6 = (__Pyx_PySequence_ContainsTF(__pyx_t_4, __pyx_t_1, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PySequence_ContainsTF(__pyx_t_4, __pyx_t_1, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 4893, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_7 = (__pyx_t_6 != 0);
@@ -55994,18 +55327,18 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* ierr = nc_def_enum(grp._grpid, xtype_tmp, namstring, &xtype);
* if ierr != NC_NOERR:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_intnptonctype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4896; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_intnptonctype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4896, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_str); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4896; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_dt, __pyx_n_s_str); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4896, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_4, 1, 0, NULL, NULL, &__pyx_slice__100, 1, 0, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4896; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_4, 1, 0, NULL, NULL, &__pyx_slice__93, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4896, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyObject_GetItem(__pyx_t_1, __pyx_t_3); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4896; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4896, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_8 = __Pyx_PyInt_As_nc_type(__pyx_t_4); if (unlikely((__pyx_t_8 == (nc_type)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4896; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_As_nc_type(__pyx_t_4); if (unlikely((__pyx_t_8 == (nc_type)-1) && PyErr_Occurred())) __PYX_ERR(0, 4896, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_xtype_tmp = __pyx_t_8;
@@ -56016,9 +55349,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4897, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4897; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4897, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_ierr = nc_def_enum(__pyx_t_9, __pyx_v_xtype_tmp, __pyx_v_namstring, (&__pyx_v_xtype));
@@ -56040,20 +55373,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* msg="unsupported datatype specified for Enum (must be integer)"
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_4 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4899, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4899, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4899, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4899, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4898
* xtype_tmp = _intnptonctype[dt.str[1:]]
@@ -56092,17 +55425,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* # insert named members into enum type.
* for field in enum_dict:
*/
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4902, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_msg);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4902, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4902, __pyx_L1_error)
}
__pyx_L3:;
@@ -56117,26 +55450,26 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
__pyx_t_3 = __pyx_v_enum_dict; __Pyx_INCREF(__pyx_t_3); __pyx_t_10 = 0;
__pyx_t_11 = NULL;
} else {
- __pyx_t_10 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_enum_dict); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4904; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_enum_dict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_11 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4904; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4904, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_11)) {
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_10); __Pyx_INCREF(__pyx_t_4); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4904; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_10); __Pyx_INCREF(__pyx_t_4); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 4904, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4904; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_10 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_10); __Pyx_INCREF(__pyx_t_4); __pyx_t_10++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4904; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_10); __Pyx_INCREF(__pyx_t_4); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(0, 4904, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4904; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_3, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4904, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -56146,7 +55479,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4904; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 4904, __pyx_L1_error)
}
break;
}
@@ -56162,7 +55495,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* bytestr = _strencode(field)
* namstring = bytestr
*/
- __pyx_t_4 = PyObject_GetItem(__pyx_v_enum_dict, __pyx_v_field); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4905; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_enum_dict, __pyx_v_field); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4905, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_4);
__pyx_t_4 = 0;
@@ -56174,7 +55507,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* namstring = bytestr
* val = value
*/
- __pyx_t_4 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_field, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4906; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __pyx_f_7netCDF4_8_netCDF4__strencode(__pyx_v_field, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4906, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF_SET(__pyx_v_bytestr, __pyx_t_4);
__pyx_t_4 = 0;
@@ -56186,7 +55519,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* val = value
* ierr = nc_insert_enum(grp._grpid, xtype, namstring, &val)
*/
- __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4907; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_AsString(__pyx_v_bytestr); if (unlikely((!__pyx_t_2) && PyErr_Occurred())) __PYX_ERR(0, 4907, __pyx_L1_error)
__pyx_v_namstring = __pyx_t_2;
/* "netCDF4/_netCDF4.pyx":4908
@@ -56196,7 +55529,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* ierr = nc_insert_enum(grp._grpid, xtype, namstring, &val)
* if ierr != NC_NOERR:
*/
- __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4908; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_value); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4908, __pyx_L1_error)
__pyx_v_val = __pyx_t_9;
/* "netCDF4/_netCDF4.pyx":4909
@@ -56206,9 +55539,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* if ierr != NC_NOERR:
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_grp, __pyx_n_s_grpid); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4909, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4909; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4909, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_ierr = nc_insert_enum(__pyx_t_9, __pyx_v_xtype, __pyx_v_namstring, (&__pyx_v_val));
@@ -56230,20 +55563,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
*
*/
__pyx_t_2 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_4 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4911; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_decode_c_string(__pyx_t_2, 0, strlen(__pyx_t_2), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4911; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4911; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4911; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4911, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4910
* val = value
@@ -56272,9 +55605,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__def_enum(PyObject *__pyx_v_grp, PyO
* cdef _read_enum(group, nc_type xtype, endian=None):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4912; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4912; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
@@ -56351,9 +55684,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
PyObject *__pyx_t_13 = NULL;
int __pyx_t_14;
size_t __pyx_t_15;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_read_enum", 0);
if (__pyx_optional_args) {
if (__pyx_optional_args->__pyx_n > 0) {
@@ -56368,9 +55698,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* # get name, datatype, and number of members.
* with nogil:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4924; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_group, __pyx_n_s_grpid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4924, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4924; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4924, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v__grpid = __pyx_t_2;
@@ -56434,20 +55764,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* try:
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4930; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4930; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4930; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4930; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4930, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4929
* ierr = nc_inq_enum(_grpid, xtype, enum_namstring, &base_xtype, NULL,\
@@ -56465,14 +55795,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* try:
* datatype = _nctonptype[base_xtype]
*/
- __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_enum_namstring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_FromString(__pyx_v_enum_namstring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -56486,7 +55816,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -56497,7 +55827,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7);
__pyx_t_5 = 0;
__pyx_t_7 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4931; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -56512,6 +55842,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* if endian is not None: datatype = endian + datatype
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
@@ -56525,9 +55857,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* if endian is not None: datatype = endian + datatype
* dt = numpy.dtype(datatype) # see if it is a primitive type
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4933; __pyx_clineno = __LINE__; goto __pyx_L7_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4933, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_base_xtype, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(__pyx_t_6 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4933; __pyx_clineno = __LINE__; goto __pyx_L7_error;};
+ __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_base_xtype, nc_type, 1, __Pyx_PyInt_From_nc_type, 0, 1, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4933, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_datatype = __pyx_t_6;
@@ -56543,7 +55875,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
__pyx_t_3 = (__pyx_v_endian != Py_None);
__pyx_t_14 = (__pyx_t_3 != 0);
if (__pyx_t_14) {
- __pyx_t_6 = PyNumber_Add(__pyx_v_endian, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4934; __pyx_clineno = __LINE__; goto __pyx_L7_error;}
+ __pyx_t_6 = PyNumber_Add(__pyx_v_endian, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4934, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF_SET(__pyx_v_datatype, __pyx_t_6);
__pyx_t_6 = 0;
@@ -56556,9 +55888,9 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* except KeyError:
* raise KeyError("unsupported component type for VLEN")
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4935; __pyx_clineno = __LINE__; goto __pyx_L7_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4935, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4935; __pyx_clineno = __LINE__; goto __pyx_L7_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dtype); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4935, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -56572,16 +55904,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
}
}
if (!__pyx_t_1) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4935; __pyx_clineno = __LINE__; goto __pyx_L7_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_datatype); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4935, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_6);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4935; __pyx_clineno = __LINE__; goto __pyx_L7_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4935, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_INCREF(__pyx_v_datatype);
__Pyx_GIVEREF(__pyx_v_datatype);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_datatype);
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4935; __pyx_clineno = __LINE__; goto __pyx_L7_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4935, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -56602,6 +55934,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
goto __pyx_L14_try_end;
__pyx_L7_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -56616,10 +55949,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* raise KeyError("unsupported component type for VLEN")
* # loop over members, build dict.
*/
- __pyx_t_2 = PyErr_ExceptionMatches(__pyx_builtin_KeyError);
+ __pyx_t_2 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_2) {
__Pyx_AddTraceback("netCDF4._netCDF4._read_enum", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_10, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4936; __pyx_clineno = __LINE__; goto __pyx_L9_except_error;}
+ if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_10, &__pyx_t_7) < 0) __PYX_ERR(0, 4936, __pyx_L9_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GOTREF(__pyx_t_7);
@@ -56631,11 +55964,11 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* # loop over members, build dict.
* enum_dict = {}
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__101, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4937; __pyx_clineno = __LINE__; goto __pyx_L9_except_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_KeyError, __pyx_tuple__94, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4937, __pyx_L9_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4937; __pyx_clineno = __LINE__; goto __pyx_L9_except_error;}
+ __PYX_ERR(0, 4937, __pyx_L9_except_error)
}
goto __pyx_L9_except_error;
__pyx_L9_except_error:;
@@ -56647,6 +55980,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* datatype = _nctonptype[base_xtype]
* if endian is not None: datatype = endian + datatype
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
@@ -56662,7 +55996,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* for nmem from 0 <= nmem < nmembers:
* with nogil:
*/
- __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4939, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_v_enum_dict = ((PyObject*)__pyx_t_7);
__pyx_t_7 = 0;
@@ -56737,20 +56071,20 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* enum_dict[name] = int(enum_val)
*/
__pyx_t_4 = ((char *)nc_strerror(__pyx_v_ierr));
- __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_decode_c_string(__pyx_t_4, 0, strlen(__pyx_t_4), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4945, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4944
* ierr = nc_inq_enum_member(_grpid, xtype, nmem, \
@@ -56768,14 +56102,14 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* enum_dict[name] = int(enum_val)
* return EnumType(group, dt, name, enum_dict, typeid=xtype)
*/
- __pyx_t_10 = __Pyx_PyObject_FromString(__pyx_v_enum_namstring); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4946; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_FromString(__pyx_v_enum_namstring); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4946; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_decode); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4946; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4946; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_unicode_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = NULL;
__pyx_t_9 = 0;
@@ -56789,7 +56123,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
__pyx_t_9 = 1;
}
}
- __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4946; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
@@ -56800,7 +56134,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_9, __pyx_t_1);
__pyx_t_10 = 0;
__pyx_t_1 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4946; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -56814,17 +56148,17 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* return EnumType(group, dt, name, enum_dict, typeid=xtype)
*
*/
- __pyx_t_7 = __Pyx_PyInt_From_char(__pyx_v_enum_val); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4947; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyInt_From_char(__pyx_v_enum_val); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4947, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4947; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4947, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
__pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyInt_Type)), __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4947; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)(&PyInt_Type)), __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4947, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (unlikely(PyDict_SetItem(__pyx_v_enum_dict, __pyx_v_name, __pyx_t_7) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4947; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItem(__pyx_v_enum_dict, __pyx_v_name, __pyx_t_7) < 0)) __PYX_ERR(0, 4947, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -56836,7 +56170,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
* cdef _strencode(pystr,encoding=None):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4948; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_v_group);
__Pyx_GIVEREF(__pyx_v_group);
@@ -56850,13 +56184,13 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__read_enum(PyObject *__pyx_v_group,
__Pyx_INCREF(__pyx_v_enum_dict);
__Pyx_GIVEREF(__pyx_v_enum_dict);
PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_v_enum_dict);
- __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4948; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_8 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4948; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyInt_From_nc_type(__pyx_v_xtype); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
- if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_typeid, __pyx_t_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4948; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_typeid, __pyx_t_8) < 0) __PYX_ERR(0, 4948, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_EnumType), __pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4948; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_EnumType), __pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -56914,9 +56248,6 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__strencode(PyObject *__pyx_v_pystr,
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
int __pyx_t_10;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_strencode", 0);
if (__pyx_optional_args) {
if (__pyx_optional_args->__pyx_n > 0) {
@@ -56943,7 +56274,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__strencode(PyObject *__pyx_v_pystr,
* try:
* return pystr.encode(encoding)
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4954, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF_SET(__pyx_v_encoding, __pyx_t_3);
__pyx_t_3 = 0;
@@ -56965,6 +56296,8 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__strencode(PyObject *__pyx_v_pystr,
* except (AttributeError, UnicodeDecodeError):
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_5);
@@ -56979,7 +56312,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__strencode(PyObject *__pyx_v_pystr,
* return pystr # already bytes or unicode?
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_pystr, __pyx_n_s_encode); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4956; __pyx_clineno = __LINE__; goto __pyx_L4_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_pystr, __pyx_n_s_encode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4956, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -56992,16 +56325,16 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__strencode(PyObject *__pyx_v_pystr,
}
}
if (!__pyx_t_8) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_encoding); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4956; __pyx_clineno = __LINE__; goto __pyx_L4_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_encoding); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4956, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4956; __pyx_clineno = __LINE__; goto __pyx_L4_error;}
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4956, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_INCREF(__pyx_v_encoding);
__Pyx_GIVEREF(__pyx_v_encoding);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_encoding);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4956; __pyx_clineno = __LINE__; goto __pyx_L4_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4956, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
@@ -57019,6 +56352,7 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__strencode(PyObject *__pyx_v_pystr,
*/
}
__pyx_L4_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -57031,10 +56365,10 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__strencode(PyObject *__pyx_v_pystr,
* return pystr # already bytes or unicode?
*
*/
- __pyx_t_10 = PyErr_ExceptionMatches(__pyx_builtin_AttributeError) || PyErr_ExceptionMatches(__pyx_builtin_UnicodeDecodeError);
+ __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_UnicodeDecodeError);
if (__pyx_t_10) {
__Pyx_AddTraceback("netCDF4._netCDF4._strencode", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_7, &__pyx_t_9) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4957; __pyx_clineno = __LINE__; goto __pyx_L6_except_error;}
+ if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_7, &__pyx_t_9) < 0) __PYX_ERR(0, 4957, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_9);
@@ -57064,18 +56398,21 @@ static PyObject *__pyx_f_7netCDF4_8_netCDF4__strencode(PyObject *__pyx_v_pystr,
* return pystr.encode(encoding)
* except (AttributeError, UnicodeDecodeError):
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
goto __pyx_L1_error;
__pyx_L8_try_return:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
goto __pyx_L0;
__pyx_L7_except_return:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
@@ -57135,9 +56472,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6_to_ascii(CYTHON_UNUSED PyObject *
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_to_ascii", 0);
/* "netCDF4/_netCDF4.pyx":4962
@@ -57147,9 +56481,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6_to_ascii(CYTHON_UNUSED PyObject *
* return str(bytestr,encoding='ascii')
* else:
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4962; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_python3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4962; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 4962, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
@@ -57161,15 +56495,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6_to_ascii(CYTHON_UNUSED PyObject *
* return bytestr.encode('ascii')
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4963; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_bytestr);
__Pyx_GIVEREF(__pyx_v_bytestr);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_bytestr);
- __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4963; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_encoding, __pyx_n_s_ascii) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4963; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4963; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_encoding, __pyx_n_s_ascii) < 0) __PYX_ERR(0, 4963, __pyx_L1_error)
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -57195,9 +56529,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6_to_ascii(CYTHON_UNUSED PyObject *
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytestr, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4965; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_bytestr, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__102, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4965; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__95, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __pyx_t_3;
@@ -57277,9 +56611,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
PyObject *(*__pyx_t_11)(PyObject *);
Py_ssize_t __pyx_t_12;
int __pyx_t_13;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_dateparse", 0);
/* "netCDF4/_netCDF4.pyx":4982
@@ -57289,7 +56620,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* units = timestr_split[0].lower()
* if timestr_split[1].lower() != 'since':
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_timestr, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_timestr, __pyx_n_s_split); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4982, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -57302,10 +56633,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4982, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4982; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4982, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -57319,9 +56650,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* if timestr_split[1].lower() != 'since':
* raise ValueError("no 'since' in unit_string")
*/
- __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_timestr_split, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4983; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_timestr_split, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4983, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_lower); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_lower); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4983, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -57335,10 +56666,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
}
}
if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4983, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4983; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4983, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -57352,9 +56683,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* raise ValueError("no 'since' in unit_string")
* # parse the date string.
*/
- __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_timestr_split, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4984; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_timestr_split, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -57368,14 +56699,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4984, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4984, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_since, Py_NE)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_since, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 4984, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_4) {
@@ -57386,11 +56717,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* # parse the date string.
* n = timestr.find('since')+6
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__103, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4985; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4985, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4985; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4985, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4984
* timestr_split = timestr.split()
@@ -57408,12 +56739,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* isostring = timestr[n:]
* year, month, day, hour, minute, second, utc_offset =\
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_timestr, __pyx_n_s_find); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_timestr, __pyx_n_s_find); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__104, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__97, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_6, 6, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_AddObjC(__pyx_t_2, __pyx_int_6, 6, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_n = __pyx_t_1;
@@ -57426,7 +56757,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* year, month, day, hour, minute, second, utc_offset =\
* _parse_date( isostring.strip() )
*/
- __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_timestr, 0, 0, &__pyx_v_n, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4988; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_timestr, 0, 0, &__pyx_v_n, NULL, NULL, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4988, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_isostring = __pyx_t_1;
__pyx_t_1 = 0;
@@ -57438,9 +56769,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* if year >= MINYEAR:
* basedate = datetime(year, month, day, hour, minute, second)
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_parse_date); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_parse_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4990, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_isostring, __pyx_n_s_strip); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_isostring, __pyx_n_s_strip); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4990, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -57453,10 +56784,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
}
}
if (__pyx_t_6) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4990, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4990, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -57471,17 +56802,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
}
}
if (!__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4990, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4990, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4990, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -57496,7 +56827,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
if (unlikely(size != 7)) {
if (size > 7) __Pyx_RaiseTooManyValuesError(7);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4989, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -57528,7 +56859,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
Py_ssize_t i;
PyObject** temps[7] = {&__pyx_t_2,&__pyx_t_6,&__pyx_t_3,&__pyx_t_5,&__pyx_t_7,&__pyx_t_8,&__pyx_t_9};
for (i=0; i < 7; i++) {
- PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 4989, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
@@ -57538,7 +56869,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
} else {
Py_ssize_t index = -1;
PyObject** temps[7] = {&__pyx_t_2,&__pyx_t_6,&__pyx_t_3,&__pyx_t_5,&__pyx_t_7,&__pyx_t_8,&__pyx_t_9};
- __pyx_t_10 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4989, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_10)->tp_iternext;
@@ -57547,7 +56878,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 7) < 0) __PYX_ERR(0, 4989, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
goto __pyx_L5_unpacking_done;
@@ -57555,7 +56886,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4989, __pyx_L1_error)
__pyx_L5_unpacking_done:;
}
@@ -57588,11 +56919,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* basedate = datetime(year, month, day, hour, minute, second)
* # add utc_offset to basedate time instance (which is timezone naive)
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4991, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_9 = PyObject_RichCompare(__pyx_v_year, __pyx_t_1, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_RichCompare(__pyx_v_year, __pyx_t_1, Py_GE); __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4991, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 4991, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
if (__pyx_t_4) {
@@ -57603,7 +56934,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* # add utc_offset to basedate time instance (which is timezone naive)
* basedate += timedelta(days=utc_offset/1440.)
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4992; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4992, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_8 = NULL;
__pyx_t_12 = 0;
@@ -57617,7 +56948,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
__pyx_t_12 = 1;
}
}
- __pyx_t_7 = PyTuple_New(6+__pyx_t_12); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4992; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(6+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4992, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -57640,7 +56971,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
__Pyx_INCREF(__pyx_v_second);
__Pyx_GIVEREF(__pyx_v_second);
PyTuple_SET_ITEM(__pyx_t_7, 5+__pyx_t_12, __pyx_v_second);
- __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4992; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4992, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -57654,19 +56985,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* else:
* if not utc_offset:
*/
- __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_timedelta); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4994; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_GetModuleGlobalName(__pyx_n_s_timedelta); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4994, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4994; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4994, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyFloat_DivideObjC(__pyx_v_utc_offset, __pyx_float_1440_, 1440., 0); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4994; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyFloat_DivideObjC(__pyx_v_utc_offset, __pyx_float_1440_, 1440., 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4994, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_days, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4994; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_days, __pyx_t_7) < 0) __PYX_ERR(0, 4994, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4994; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4994, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_basedate, __pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4994; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_basedate, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4994, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF_SET(__pyx_v_basedate, __pyx_t_1);
@@ -57690,7 +57021,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* else:
*/
/*else*/ {
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_utc_offset); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4996; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_utc_offset); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 4996, __pyx_L1_error)
__pyx_t_13 = ((!__pyx_t_4) != 0);
if (__pyx_t_13) {
@@ -57701,9 +57032,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
* else:
* raise ValueError('cannot use utc_offset for reference years <= 0')
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4997, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_datetime); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_datetime); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4997, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = NULL;
@@ -57718,7 +57049,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
__pyx_t_12 = 1;
}
}
- __pyx_t_8 = PyTuple_New(6+__pyx_t_12); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(6+__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4997, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -57741,7 +57072,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
__Pyx_INCREF(__pyx_v_second);
__Pyx_GIVEREF(__pyx_v_second);
PyTuple_SET_ITEM(__pyx_t_8, 5+__pyx_t_12, __pyx_v_second);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4997, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
@@ -57766,11 +57097,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_8_dateparse(CYTHON_UNUSED PyObject
*
*/
/*else*/ {
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__105, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__98, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4999, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 4999, __pyx_L1_error)
}
__pyx_L7:;
}
@@ -57843,9 +57174,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_11stringtoarr(PyObject *__pyx_self,
PyObject *__pyx_v_string = 0;
PyObject *__pyx_v_NUMCHARS = 0;
PyObject *__pyx_v_dtype = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("stringtoarr (wrapper)", 0);
@@ -57871,7 +57199,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_11stringtoarr(PyObject *__pyx_self,
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_NUMCHARS)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("stringtoarr", 0, 2, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5002; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("stringtoarr", 0, 2, 3, 1); __PYX_ERR(0, 5002, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
@@ -57880,7 +57208,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_11stringtoarr(PyObject *__pyx_self,
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stringtoarr") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5002; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "stringtoarr") < 0)) __PYX_ERR(0, 5002, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -57897,7 +57225,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_11stringtoarr(PyObject *__pyx_self,
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("stringtoarr", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5002; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("stringtoarr", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5002, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.stringtoarr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -57922,9 +57250,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10stringtoarr(CYTHON_UNUSED PyObjec
PyObject *__pyx_t_6 = NULL;
Py_ssize_t __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("stringtoarr", 0);
/* "netCDF4/_netCDF4.pyx":5019
@@ -57936,13 +57261,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10stringtoarr(CYTHON_UNUSED PyObjec
*/
__Pyx_INCREF(__pyx_v_dtype);
__pyx_t_1 = __pyx_v_dtype;
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_S, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5019; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_S, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5019, __pyx_L1_error)
if (__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_U, Py_NE)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5019; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_U, Py_NE)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5019, __pyx_L1_error)
__pyx_t_2 = __pyx_t_3;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -57956,11 +57281,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10stringtoarr(CYTHON_UNUSED PyObjec
* arr = numpy.zeros(NUMCHARS,dtype+'1')
* arr[0:len(string)] = tuple(string)
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__106, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__99, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5020, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5020, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5019
* returns a rank 1 numpy character array of length NUMCHARS with datatype `'S1'`
@@ -57978,12 +57303,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10stringtoarr(CYTHON_UNUSED PyObjec
* arr[0:len(string)] = tuple(string)
* return arr
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5021; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5021, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5021; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5021, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyNumber_Add(__pyx_v_dtype, __pyx_kp_s_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5021; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Add(__pyx_v_dtype, __pyx_kp_s_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5021, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
__pyx_t_7 = 0;
@@ -57997,7 +57322,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10stringtoarr(CYTHON_UNUSED PyObjec
__pyx_t_7 = 1;
}
}
- __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5021; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5021, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
@@ -58008,7 +57333,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10stringtoarr(CYTHON_UNUSED PyObjec
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5021; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5021, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -58022,10 +57347,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10stringtoarr(CYTHON_UNUSED PyObjec
* return arr
*
*/
- __pyx_t_1 = PySequence_Tuple(__pyx_v_string); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5022; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_Tuple(__pyx_v_string); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5022, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = PyObject_Length(__pyx_v_string); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5022; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (__Pyx_PyObject_SetSlice(__pyx_v_arr, __pyx_t_1, 0, __pyx_t_7, NULL, NULL, NULL, 1, 1, 1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5022; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_Length(__pyx_v_string); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 5022, __pyx_L1_error)
+ if (__Pyx_PyObject_SetSlice(__pyx_v_arr, __pyx_t_1, 0, __pyx_t_7, NULL, NULL, NULL, 1, 1, 1) < 0) __PYX_ERR(0, 5022, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5023
@@ -58102,9 +57427,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
Py_ssize_t __pyx_t_10;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("stringtochar", 0);
/* "netCDF4/_netCDF4.pyx":5037
@@ -58114,9 +57436,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
* if dtype not in ["S","U"]:
* raise ValueError("type must string or unicode ('S' or 'U')")
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5037, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_kind); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_kind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5037, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_dtype = __pyx_t_2;
@@ -58131,13 +57453,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
*/
__Pyx_INCREF(__pyx_v_dtype);
__pyx_t_2 = __pyx_v_dtype;
- __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_S, Py_NE)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5038; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_S, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 5038, __pyx_L1_error)
if (__pyx_t_4) {
} else {
__pyx_t_3 = __pyx_t_4;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_U, Py_NE)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5038; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_U, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 5038, __pyx_L1_error)
__pyx_t_3 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -58151,11 +57473,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
* b = numpy.array(tuple(a.tostring().decode(default_encoding)),dtype+'1')
* b.shape = a.shape + (a.itemsize,)
*/
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__107, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5039; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__100, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5039, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5039; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5039, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5038
* and shape `a.shape + (N,)`, where N is the length of each string in a."""
@@ -58173,12 +57495,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
* b.shape = a.shape + (a.itemsize,)
* return b
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_tostring); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_tostring); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -58191,17 +57513,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
}
}
if (__pyx_t_8) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else {
- __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5040, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_decode); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_7))) {
@@ -58214,25 +57536,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
}
}
if (!__pyx_t_8) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_Tuple(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_Add(__pyx_v_dtype, __pyx_kp_s_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_v_dtype, __pyx_kp_s_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_9 = NULL;
__pyx_t_10 = 0;
@@ -58246,7 +57568,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
__pyx_t_10 = 1;
}
}
- __pyx_t_6 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_9) {
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_9); __pyx_t_9 = NULL;
@@ -58257,7 +57579,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_10, __pyx_t_1);
__pyx_t_7 = 0;
__pyx_t_1 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5040, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -58271,20 +57593,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_12stringtochar(CYTHON_UNUSED PyObje
* return b
*
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5041, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_a, __pyx_n_s_itemsize); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5041, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5041, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5);
__pyx_t_5 = 0;
- __pyx_t_5 = PyNumber_Add(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyNumber_Add(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5041, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_b, __pyx_n_s_shape, __pyx_t_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_b, __pyx_n_s_shape, __pyx_t_5) < 0) __PYX_ERR(0, 5041, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "netCDF4/_netCDF4.pyx":5042
@@ -58367,9 +57689,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
Py_ssize_t __pyx_t_8;
PyObject *(*__pyx_t_9)(PyObject *);
PyObject *__pyx_t_10 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("chartostring", 0);
/* "netCDF4/_netCDF4.pyx":5056
@@ -58379,9 +57698,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
* if dtype not in ["S","U"]:
* raise ValueError("type must string or unicode ('S' or 'U')")
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5056, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_kind); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_kind); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5056, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_dtype = __pyx_t_2;
@@ -58396,13 +57715,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
*/
__Pyx_INCREF(__pyx_v_dtype);
__pyx_t_2 = __pyx_v_dtype;
- __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_S, Py_NE)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_S, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 5057, __pyx_L1_error)
if (__pyx_t_4) {
} else {
__pyx_t_3 = __pyx_t_4;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_U, Py_NE)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_t_2, __pyx_n_s_U, Py_NE)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 5057, __pyx_L1_error)
__pyx_t_3 = __pyx_t_4;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -58416,11 +57735,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
* bs = b.tostring().decode(default_encoding)
* slen = int(b.shape[-1])
*/
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__108, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__101, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5058, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5058, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5057
* `b.shape[:-1]` where where `N=b.shape[-1]`."""
@@ -58438,7 +57757,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
* slen = int(b.shape[-1])
* a = numpy.array([bs[n1:n1+slen] for n1 in range(0,len(bs),slen)],dtype+repr(slen))
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_tostring); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_tostring); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5059, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -58451,17 +57770,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5059, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5059, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_decode); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5059, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_default_encoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5059, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -58474,17 +57793,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
}
}
if (!__pyx_t_6) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5059, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5059, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5059; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5059, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -58499,12 +57818,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
* a = numpy.array([bs[n1:n1+slen] for n1 in range(0,len(bs),slen)],dtype+repr(slen))
* a.shape = b.shape[:-1]
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5060, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, -1L, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5060; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_2, -1L, long, 1, __Pyx_PyInt_From_long, 0, 1, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5060, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Int(__pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyNumber_Int(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5060, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_slen = __pyx_t_2;
@@ -58517,17 +57836,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
* a.shape = b.shape[:-1]
* return a
*/
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_array); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_8 = PyObject_Length(__pyx_v_bs); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyObject_Length(__pyx_v_bs); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5061, __pyx_L1_error)
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_int_0);
__Pyx_GIVEREF(__pyx_int_0);
@@ -58538,16 +57857,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
__Pyx_GIVEREF(__pyx_v_slen);
PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_slen);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_6 = __pyx_t_1; __Pyx_INCREF(__pyx_t_6); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
} else {
- __pyx_t_8 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_9 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5061, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -58555,17 +57874,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_8); __Pyx_INCREF(__pyx_t_1); __pyx_t_8++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_8); __Pyx_INCREF(__pyx_t_1); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 5061, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_6, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_6, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_8); __Pyx_INCREF(__pyx_t_1); __pyx_t_8++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_8); __Pyx_INCREF(__pyx_t_1); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(0, 5061, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_6, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_6, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -58575,7 +57894,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5061, __pyx_L1_error)
}
break;
}
@@ -58583,18 +57902,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
}
__Pyx_XDECREF_SET(__pyx_v_n1, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_Add(__pyx_v_n1, __pyx_v_slen); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_v_n1, __pyx_v_slen); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_10 = __Pyx_PyObject_GetSlice(__pyx_v_bs, 0, 0, &__pyx_v_n1, &__pyx_t_1, NULL, 0, 0, 1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetSlice(__pyx_v_bs, 0, 0, &__pyx_v_n1, &__pyx_t_1, NULL, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_10))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_5, (PyObject*)__pyx_t_10))) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = PyObject_Repr(__pyx_v_slen); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_Repr(__pyx_v_slen); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = PyNumber_Add(__pyx_v_dtype, __pyx_t_6); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyNumber_Add(__pyx_v_dtype, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -58609,7 +57928,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
__pyx_t_8 = 1;
}
}
- __pyx_t_1 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6); __pyx_t_6 = NULL;
@@ -58620,7 +57939,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_8, __pyx_t_10);
__pyx_t_5 = 0;
__pyx_t_10 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5061; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -58634,12 +57953,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_14chartostring(CYTHON_UNUSED PyObje
* return a
*
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5062; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_b, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5062, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_2, 0, -1L, NULL, NULL, &__pyx_slice__109, 0, 1, 1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5062; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_2, 0, -1L, NULL, NULL, &__pyx_slice__102, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5062, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_a, __pyx_n_s_shape, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5062; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_a, __pyx_n_s_shape, __pyx_t_7) < 0) __PYX_ERR(0, 5062, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5063
@@ -58699,9 +58018,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_17date2num(PyObject *__pyx_self, Py
PyObject *__pyx_v_dates = 0;
PyObject *__pyx_v_units = 0;
PyObject *__pyx_v_calendar = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("date2num (wrapper)", 0);
@@ -58727,7 +58043,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_17date2num(PyObject *__pyx_self, Py
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_units)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("date2num", 0, 2, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5065; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("date2num", 0, 2, 3, 1); __PYX_ERR(0, 5065, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
@@ -58736,7 +58052,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_17date2num(PyObject *__pyx_self, Py
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "date2num") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5065; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "date2num") < 0)) __PYX_ERR(0, 5065, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -58753,7 +58069,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_17date2num(PyObject *__pyx_self, Py
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("date2num", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5065; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("date2num", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5065, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.date2num", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -58796,9 +58112,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
PyObject *(*__pyx_t_13)(PyObject *);
int __pyx_t_14;
PyObject *__pyx_t_15 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("date2num", 0);
__Pyx_INCREF(__pyx_v_dates);
__Pyx_INCREF(__pyx_v_calendar);
@@ -58810,7 +58123,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* basedate = _dateparse(units)
* unit = units.split()[0].lower()
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_calendar, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5094; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_calendar, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5094, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -58823,10 +58136,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5094; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5094, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5094; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5094, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -58840,7 +58153,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* unit = units.split()[0].lower()
* # real-world calendars limited to positive reference years.
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_dateparse); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_dateparse); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -58853,16 +58166,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_units); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_units); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_units);
__Pyx_GIVEREF(__pyx_v_units);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_units);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5095; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -58877,7 +58190,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* # real-world calendars limited to positive reference years.
* if calendar in ['julian', 'standard', 'gregorian', 'proleptic_gregorian']:
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_units, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5096; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_units, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5096, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -58890,17 +58203,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
}
}
if (__pyx_t_3) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5096; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5096, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5096; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5096, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5096; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5096, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5096; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5096, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -58914,10 +58227,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5096; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5096, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5096; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5096, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -58933,25 +58246,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
*/
__Pyx_INCREF(__pyx_v_calendar);
__pyx_t_1 = __pyx_v_calendar;
- __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_julian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5098; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_julian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5098, __pyx_L1_error)
if (!__pyx_t_6) {
} else {
__pyx_t_5 = __pyx_t_6;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5098; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5098, __pyx_L1_error)
if (!__pyx_t_6) {
} else {
__pyx_t_5 = __pyx_t_6;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5098; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5098, __pyx_L1_error)
if (!__pyx_t_6) {
} else {
__pyx_t_5 = __pyx_t_6;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5098; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5098, __pyx_L1_error)
__pyx_t_5 = __pyx_t_6;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -58965,12 +58278,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* msg='zero not allowed as a reference year, does not exist in Julian or Gregorian calendars'
* raise ValueError(msg)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5099; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5099, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5099; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5099, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5099; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5099, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_6) {
@@ -58991,17 +58304,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* elif basedate.year < 0:
* msg='negative reference year in time units, must be >= 1'
*/
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5101; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5101; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5101; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5101, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5099
* # real-world calendars limited to positive reference years.
@@ -59019,11 +58332,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* msg='negative reference year in time units, must be >= 1'
* raise ValueError(msg)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5102, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5102, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5102; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5102, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_6) {
@@ -59044,17 +58357,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
*
* if (calendar == 'proleptic_gregorian' and basedate.year >= MINYEAR) or \
*/
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5104; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5104, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5104; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5104, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5104; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5104, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5102
* msg='zero not allowed as a reference year, does not exist in Julian or Gregorian calendars'
@@ -59081,19 +58394,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* (calendar in ['gregorian','standard'] and basedate > gregorian):
* # use python datetime module,
*/
- __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_v_calendar, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_v_calendar, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5106, __pyx_L1_error)
if (!__pyx_t_5) {
goto __pyx_L11_next_or;
} else {
}
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5106, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5106, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5106, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5106; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5106, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (!__pyx_t_5) {
} else {
@@ -59111,13 +58424,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
*/
__Pyx_INCREF(__pyx_v_calendar);
__pyx_t_4 = __pyx_v_calendar;
- __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5107, __pyx_L1_error)
if (!__pyx_t_7) {
} else {
__pyx_t_5 = __pyx_t_7;
goto __pyx_L14_bool_binop_done;
}
- __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5107, __pyx_L1_error)
__pyx_t_5 = __pyx_t_7;
__pyx_L14_bool_binop_done:;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -59127,11 +58440,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
__pyx_t_6 = __pyx_t_7;
goto __pyx_L10_bool_binop_done;
}
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_gregorian); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_gregorian); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5107, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = PyObject_RichCompare(__pyx_v_basedate, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_v_basedate, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5107, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5107; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5107, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_6 = __pyx_t_7;
__pyx_L10_bool_binop_done:;
@@ -59162,6 +58475,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* except:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_9);
@@ -59175,7 +58490,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* except:
* isscalar = True
*/
- __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_dates, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5111; __pyx_clineno = __LINE__; goto __pyx_L16_error;};
+ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_dates, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5111, __pyx_L16_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -59192,6 +58507,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
goto __pyx_L23_try_end;
__pyx_L16_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -59206,7 +58522,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
*/
/*except:*/ {
__Pyx_AddTraceback("netCDF4._netCDF4.date2num", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5112; __pyx_clineno = __LINE__; goto __pyx_L18_except_error;}
+ if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_1) < 0) __PYX_ERR(0, 5112, __pyx_L18_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_1);
@@ -59233,12 +58549,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* dates[0]
* except:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
goto __pyx_L1_error;
__pyx_L17_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
@@ -59263,12 +58581,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* else:
* dates = numpy.array(dates)
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5115; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5115; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_array); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5115; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_dates);
__Pyx_GIVEREF(__pyx_v_dates);
@@ -59284,17 +58602,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5115; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5115, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5115; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5115; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
}
@@ -59320,9 +58638,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* ismasked = False
*/
/*else*/ {
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5117; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5117, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5117; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5117, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -59336,16 +58654,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_dates); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5117; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_dates); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5117, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5117; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5117, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_dates);
__Pyx_GIVEREF(__pyx_v_dates);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_dates);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5117; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5117, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -59360,7 +58678,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* ismasked = False
* if hasattr(dates,'mask'):
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dates, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5118; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dates, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5118, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_shape = __pyx_t_1;
__pyx_t_1 = 0;
@@ -59383,7 +58701,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* mask = dates.mask
* ismasked = True
*/
- __pyx_t_6 = PyObject_HasAttr(__pyx_v_dates, __pyx_n_s_mask); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5120; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_HasAttr(__pyx_v_dates, __pyx_n_s_mask); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 5120, __pyx_L1_error)
__pyx_t_7 = (__pyx_t_6 != 0);
if (__pyx_t_7) {
@@ -59394,7 +58712,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* ismasked = True
* times = []
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dates, __pyx_n_s_mask); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5121; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dates, __pyx_n_s_mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5121, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_mask = __pyx_t_1;
__pyx_t_1 = 0;
@@ -59424,7 +58742,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* for date in dates.flat:
* if ismasked and not date:
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5123; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5123, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_times = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
@@ -59436,15 +58754,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* if ismasked and not date:
* times.append(None)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dates, __pyx_n_s_flat); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5124; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dates, __pyx_n_s_flat); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5124, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_11 = __pyx_t_1; __Pyx_INCREF(__pyx_t_11); __pyx_t_12 = 0;
__pyx_t_13 = NULL;
} else {
- __pyx_t_12 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5124; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5124, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
- __pyx_t_13 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5124; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5124, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -59452,17 +58770,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
if (likely(PyList_CheckExact(__pyx_t_11))) {
if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_11)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5124; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 5124, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5124; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5124, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_11)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5124; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_12); __Pyx_INCREF(__pyx_t_1); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 5124, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5124; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_11, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5124, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -59472,7 +58790,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5124; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5124, __pyx_L1_error)
}
break;
}
@@ -59494,7 +58812,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
__pyx_t_7 = __pyx_t_6;
goto __pyx_L31_bool_binop_done;
}
- __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_date); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5125; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_date); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5125, __pyx_L1_error)
__pyx_t_5 = ((!__pyx_t_6) != 0);
__pyx_t_7 = __pyx_t_5;
__pyx_L31_bool_binop_done:;
@@ -59507,7 +58825,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* else:
* td = date - basedate
*/
- __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, Py_None); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5126; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, Py_None); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(0, 5126, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5125
* times = []
@@ -59527,7 +58845,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* totaltime = td.microseconds + (td.seconds + td.days * 24 * 3600) * 1.e6
*/
/*else*/ {
- __pyx_t_1 = PyNumber_Subtract(__pyx_v_date, __pyx_v_basedate); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5128; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Subtract(__pyx_v_date, __pyx_v_basedate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5128, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_td, __pyx_t_1);
__pyx_t_1 = 0;
@@ -59539,26 +58857,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* if unit in microsec_units:
* times.append(totaltime)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_td, __pyx_n_s_microseconds); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_td, __pyx_n_s_microseconds); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_td, __pyx_n_s_seconds); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_td, __pyx_n_s_seconds); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_td, __pyx_n_s_days); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_td, __pyx_n_s_days); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_int_24); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_int_24); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_int_3600); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_int_3600); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Add(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_float_1_e6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Multiply(__pyx_t_3, __pyx_float_1_e6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5130; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5130, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -59572,9 +58890,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* times.append(totaltime)
* elif unit in millisec_units:
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_microsec_units); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5131; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_microsec_units); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5131, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5131; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5131, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_5 = (__pyx_t_7 != 0);
if (__pyx_t_5) {
@@ -59586,7 +58904,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* elif unit in millisec_units:
* times.append(totaltime/1.e3)
*/
- __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_v_totaltime); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5132; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_v_totaltime); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(0, 5132, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5131
* # total time in microseconds.
@@ -59605,9 +58923,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* times.append(totaltime/1.e3)
* elif unit in sec_units:
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_millisec_units); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5133; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_millisec_units); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5133, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5133; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5133, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_7 = (__pyx_t_5 != 0);
if (__pyx_t_7) {
@@ -59619,9 +58937,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* elif unit in sec_units:
* times.append(totaltime/1.e6)
*/
- __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e3, 1.e3, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5134; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e3, 1.e3, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5134, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_3); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5134; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_3); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(0, 5134, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "netCDF4/_netCDF4.pyx":5133
@@ -59641,9 +58959,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* times.append(totaltime/1.e6)
* elif unit in min_units:
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_sec_units); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5135; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_sec_units); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5135, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5135; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5135, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_5 = (__pyx_t_7 != 0);
if (__pyx_t_5) {
@@ -59655,9 +58973,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* elif unit in min_units:
* times.append(totaltime/1.e6/60)
*/
- __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5136; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5136, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_3); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5136; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_3); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(0, 5136, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "netCDF4/_netCDF4.pyx":5135
@@ -59677,9 +58995,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* times.append(totaltime/1.e6/60)
* elif unit in hr_units:
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_min_units); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5137; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_min_units); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5137, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5137; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5137, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_7 = (__pyx_t_5 != 0);
if (__pyx_t_7) {
@@ -59691,12 +59009,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* elif unit in hr_units:
* times.append(totaltime/1.e6/3600)
*/
- __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5138; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5138, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_int_60); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5138; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_int_60); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5138, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_2); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5138; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_2); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(0, 5138, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5137
@@ -59716,9 +59034,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* times.append(totaltime/1.e6/3600)
* elif unit in day_units:
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_hr_units); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5139; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_hr_units); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5139, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5139; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5139, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_5 = (__pyx_t_7 != 0);
if (__pyx_t_5) {
@@ -59730,12 +59048,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* elif unit in day_units:
* times.append(totaltime/1.e6/3600./24.)
*/
- __pyx_t_2 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5140; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5140, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_int_3600); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5140; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_2, __pyx_int_3600); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5140, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_3); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5140; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_3); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(0, 5140, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "netCDF4/_netCDF4.pyx":5139
@@ -59755,9 +59073,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* times.append(totaltime/1.e6/3600./24.)
* else:
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_day_units); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5141; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_day_units); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5141, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5141; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_3, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5141, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_7 = (__pyx_t_5 != 0);
if (__pyx_t_7) {
@@ -59769,15 +59087,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* else:
* raise ValueError('unsupported time units')
*/
- __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5142; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_v_totaltime, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5142, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyFloat_DivideObjC(__pyx_t_3, __pyx_float_3600_, 3600., 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5142; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyFloat_DivideObjC(__pyx_t_3, __pyx_float_3600_, 3600., 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5142, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_t_2, __pyx_float_24_, 24., 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5142; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyFloat_DivideObjC(__pyx_t_2, __pyx_float_24_, 24., 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5142, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_3); if (unlikely(__pyx_t_14 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5142; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_times, __pyx_t_3); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(0, 5142, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "netCDF4/_netCDF4.pyx":5141
@@ -59798,11 +59116,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* return times[0]
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__110, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5144; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__103, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5144, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5144; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5144, __pyx_L1_error)
}
__pyx_L33:;
}
@@ -59836,7 +59154,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* return numpy.reshape(numpy.array(times), shape)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_11 = __Pyx_GetItemInt_List(__pyx_v_times, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(__pyx_t_11 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5146; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_11 = __Pyx_GetItemInt_List(__pyx_v_times, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5146, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_r = __pyx_t_11;
__pyx_t_11 = 0;
@@ -59860,14 +59178,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_reshape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_reshape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -59881,21 +59199,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_1) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_times); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_times); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_INCREF(__pyx_v_times);
__Pyx_GIVEREF(__pyx_v_times);
PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_v_times);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- if (unlikely(!__pyx_v_shape)) { __Pyx_RaiseUnboundLocalError("shape"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
+ if (unlikely(!__pyx_v_shape)) { __Pyx_RaiseUnboundLocalError("shape"); __PYX_ERR(0, 5148, __pyx_L1_error) }
__pyx_t_4 = NULL;
__pyx_t_12 = 0;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -59908,7 +59226,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
__pyx_t_12 = 1;
}
}
- __pyx_t_15 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -59919,7 +59237,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
__Pyx_GIVEREF(__pyx_v_shape);
PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_12, __pyx_v_shape);
__pyx_t_3 = 0;
- __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_15, NULL); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5148; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_15, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -59945,20 +59263,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
*
*/
/*else*/ {
- __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5150, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_utime); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_utime); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5150, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5150, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_INCREF(__pyx_v_units);
__Pyx_GIVEREF(__pyx_v_units);
PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_v_units);
- __pyx_t_15 = PyDict_New(); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyDict_New(); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5150, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_calendar, __pyx_v_calendar) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, __pyx_t_15); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_15, __pyx_n_s_calendar, __pyx_v_calendar) < 0) __PYX_ERR(0, 5150, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, __pyx_t_15); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5150, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
@@ -59974,7 +59292,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
* def num2date(times,units,calendar='standard'):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_cdftime, __pyx_n_s_date2num); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5151; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_cdftime, __pyx_n_s_date2num); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5151, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__pyx_t_11 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_15))) {
@@ -59987,16 +59305,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_16date2num(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_11) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_v_dates); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5151; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_15, __pyx_v_dates); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5151, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5151; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5151, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_11); __pyx_t_11 = NULL;
__Pyx_INCREF(__pyx_v_dates);
__Pyx_GIVEREF(__pyx_v_dates);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_v_dates);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5151; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_15, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5151, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -60058,9 +59376,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_19num2date(PyObject *__pyx_self, Py
PyObject *__pyx_v_times = 0;
PyObject *__pyx_v_units = 0;
PyObject *__pyx_v_calendar = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("num2date (wrapper)", 0);
@@ -60086,7 +59401,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_19num2date(PyObject *__pyx_self, Py
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_units)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("num2date", 0, 2, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5153; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("num2date", 0, 2, 3, 1); __PYX_ERR(0, 5153, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
@@ -60095,7 +59410,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_19num2date(PyObject *__pyx_self, Py
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "num2date") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5153; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "num2date") < 0)) __PYX_ERR(0, 5153, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -60112,7 +59427,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_19num2date(PyObject *__pyx_self, Py
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("num2date", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5153; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("num2date", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5153, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.num2date", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -60160,9 +59475,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
int __pyx_t_13;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("num2date", 0);
__Pyx_INCREF(__pyx_v_times);
__Pyx_INCREF(__pyx_v_calendar);
@@ -60174,7 +59486,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* basedate = _dateparse(units)
* unit = units.split()[0].lower()
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_calendar, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5190; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_calendar, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5190, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -60187,10 +59499,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5190; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5190, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5190; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5190, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -60204,7 +59516,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* unit = units.split()[0].lower()
* # real-world calendars limited to positive reference years.
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_dateparse); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5191; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_dateparse); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5191, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -60217,16 +59529,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_units); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5191; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_units); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5191, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5191; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5191, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_units);
__Pyx_GIVEREF(__pyx_v_units);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_units);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5191; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5191, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -60241,7 +59553,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* # real-world calendars limited to positive reference years.
* if calendar in ['julian', 'standard', 'gregorian', 'proleptic_gregorian']:
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_units, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5192; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_units, __pyx_n_s_split); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5192, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -60254,17 +59566,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
}
}
if (__pyx_t_3) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5192; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5192, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5192; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5192, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5192; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5192, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5192; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_lower); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5192, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -60278,10 +59590,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
}
}
if (__pyx_t_4) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5192; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5192, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5192; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5192, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -60297,25 +59609,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
*/
__Pyx_INCREF(__pyx_v_calendar);
__pyx_t_1 = __pyx_v_calendar;
- __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_julian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5194; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_julian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5194, __pyx_L1_error)
if (!__pyx_t_6) {
} else {
__pyx_t_5 = __pyx_t_6;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5194; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5194, __pyx_L1_error)
if (!__pyx_t_6) {
} else {
__pyx_t_5 = __pyx_t_6;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5194; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5194, __pyx_L1_error)
if (!__pyx_t_6) {
} else {
__pyx_t_5 = __pyx_t_6;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5194; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5194, __pyx_L1_error)
__pyx_t_5 = __pyx_t_6;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -60329,12 +59641,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* msg='zero not allowed as a reference year, does not exist in Julian or Gregorian calendars'
* raise ValueError(msg)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5195; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5195, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5195; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_1, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5195, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5195; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5195, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_6) {
@@ -60355,17 +59667,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* elif basedate.year < 0:
* msg='negative reference year in time units, must be >= 1'
*/
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5197; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5197, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5197; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5197, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5197; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5197, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5195
* # real-world calendars limited to positive reference years.
@@ -60383,11 +59695,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* msg='negative reference year in time units, must be >= 1'
* raise ValueError(msg)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5198; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5198, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5198; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5198, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5198; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5198, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_6) {
@@ -60408,17 +59720,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
*
* if (calendar == 'proleptic_gregorian' and basedate.year >= MINYEAR) or \
*/
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5200; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5200, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_msg);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5200; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5200, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5200; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5200, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5198
* msg='zero not allowed as a reference year, does not exist in Julian or Gregorian calendars'
@@ -60445,19 +59757,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* (calendar in ['gregorian','standard'] and basedate > gregorian):
* # use python datetime module,
*/
- __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_v_calendar, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PyString_Equals(__pyx_v_calendar, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5202, __pyx_L1_error)
if (!__pyx_t_5) {
goto __pyx_L11_next_or;
} else {
}
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5202, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5202, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_GE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5202, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5202; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5202, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (!__pyx_t_5) {
} else {
@@ -60475,13 +59787,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
*/
__Pyx_INCREF(__pyx_v_calendar);
__pyx_t_4 = __pyx_v_calendar;
- __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5203; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5203, __pyx_L1_error)
if (!__pyx_t_7) {
} else {
__pyx_t_5 = __pyx_t_7;
goto __pyx_L14_bool_binop_done;
}
- __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5203; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_4, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5203, __pyx_L1_error)
__pyx_t_5 = __pyx_t_7;
__pyx_L14_bool_binop_done:;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -60491,11 +59803,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
__pyx_t_6 = __pyx_t_7;
goto __pyx_L10_bool_binop_done;
}
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_gregorian); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5203; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_gregorian); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5203, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_2 = PyObject_RichCompare(__pyx_v_basedate, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5203; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_v_basedate, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5203, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5203; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5203, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_6 = __pyx_t_7;
__pyx_L10_bool_binop_done:;
@@ -60526,6 +59838,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* except:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_9);
@@ -60539,7 +59853,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* except:
* isscalar = True
*/
- __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_times, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5207; __pyx_clineno = __LINE__; goto __pyx_L16_error;};
+ __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_times, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5207, __pyx_L16_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -60556,6 +59870,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
goto __pyx_L23_try_end;
__pyx_L16_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -60570,7 +59885,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
*/
/*except:*/ {
__Pyx_AddTraceback("netCDF4._netCDF4.num2date", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5208; __pyx_clineno = __LINE__; goto __pyx_L18_except_error;}
+ if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_4, &__pyx_t_1) < 0) __PYX_ERR(0, 5208, __pyx_L18_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_1);
@@ -60597,12 +59912,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* times[0]
* except:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10);
goto __pyx_L1_error;
__pyx_L17_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
@@ -60627,25 +59944,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* else:
* times = numpy.array(times, dtype='d')
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5211; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5211; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_array); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5211; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_times);
__Pyx_GIVEREF(__pyx_v_times);
PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_times);
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5211; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5211; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_n_s_d) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5211; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5211; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, __pyx_n_s_d) < 0) __PYX_ERR(0, 5211, __pyx_L1_error)
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -60671,20 +59988,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* ismasked = False
*/
/*else*/ {
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5213, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5213, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5213, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_times);
__Pyx_GIVEREF(__pyx_v_times);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_times);
- __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5213, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_n_s_d) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5213; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_n_s_d) < 0) __PYX_ERR(0, 5213, __pyx_L1_error)
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5213, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -60699,7 +60016,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* ismasked = False
* if hasattr(times,'mask'):
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_times, __pyx_n_s_shape); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_times, __pyx_n_s_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5214, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_v_shape = __pyx_t_4;
__pyx_t_4 = 0;
@@ -60722,7 +60039,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* mask = times.mask
* ismasked = True
*/
- __pyx_t_6 = PyObject_HasAttr(__pyx_v_times, __pyx_n_s_mask); if (unlikely(__pyx_t_6 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5216; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_HasAttr(__pyx_v_times, __pyx_n_s_mask); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(0, 5216, __pyx_L1_error)
__pyx_t_7 = (__pyx_t_6 != 0);
if (__pyx_t_7) {
@@ -60733,7 +60050,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* ismasked = True
* dates = []
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_times, __pyx_n_s_mask); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_times, __pyx_n_s_mask); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5217, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_v_mask = __pyx_t_4;
__pyx_t_4 = 0;
@@ -60763,7 +60080,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* for time in times.flat:
* if ismasked and not time:
*/
- __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5219; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5219, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_v_dates = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
@@ -60775,15 +60092,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* if ismasked and not time:
* dates.append(None)
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_times, __pyx_n_s_flat); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_times, __pyx_n_s_flat); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
__pyx_t_2 = __pyx_t_4; __Pyx_INCREF(__pyx_t_2); __pyx_t_11 = 0;
__pyx_t_12 = NULL;
} else {
- __pyx_t_11 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_12 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5220, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
for (;;) {
@@ -60791,17 +60108,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_11 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_11); __Pyx_INCREF(__pyx_t_4); __pyx_t_11++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_11); __Pyx_INCREF(__pyx_t_4); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 5220, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_11 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_11); __Pyx_INCREF(__pyx_t_4); __pyx_t_11++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_11); __Pyx_INCREF(__pyx_t_4); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 5220, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_2, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -60811,7 +60128,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5220; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5220, __pyx_L1_error)
}
break;
}
@@ -60833,7 +60150,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
__pyx_t_7 = __pyx_t_6;
goto __pyx_L31_bool_binop_done;
}
- __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_time); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5221; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_time); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(0, 5221, __pyx_L1_error)
__pyx_t_5 = ((!__pyx_t_6) != 0);
__pyx_t_7 = __pyx_t_5;
__pyx_L31_bool_binop_done:;
@@ -60846,7 +60163,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* else:
* # convert to total seconds
*/
- __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_dates, Py_None); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5222; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_dates, Py_None); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 5222, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5221
* dates = []
@@ -60866,9 +60183,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* elif unit in millisec_units:
*/
/*else*/ {
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_microsec_units); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_microsec_units); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5225, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5225, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_5 = (__pyx_t_7 != 0);
if (__pyx_t_5) {
@@ -60880,7 +60197,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* elif unit in millisec_units:
* tsecs = time/1.e3
*/
- __pyx_t_4 = __Pyx_PyFloat_DivideObjC(__pyx_v_time, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5226; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyFloat_DivideObjC(__pyx_v_time, __pyx_float_1_e6, 1.e6, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5226, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_tsecs, __pyx_t_4);
__pyx_t_4 = 0;
@@ -60902,9 +60219,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* tsecs = time/1.e3
* elif unit in sec_units:
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_millisec_units); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5227; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_millisec_units); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5227; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5227, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_7 = (__pyx_t_5 != 0);
if (__pyx_t_7) {
@@ -60916,7 +60233,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* elif unit in sec_units:
* tsecs = time
*/
- __pyx_t_4 = __Pyx_PyFloat_DivideObjC(__pyx_v_time, __pyx_float_1_e3, 1.e3, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5228; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyFloat_DivideObjC(__pyx_v_time, __pyx_float_1_e3, 1.e3, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_tsecs, __pyx_t_4);
__pyx_t_4 = 0;
@@ -60938,9 +60255,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* tsecs = time
* elif unit in min_units:
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_sec_units); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5229; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_sec_units); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5229, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5229; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5229, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_5 = (__pyx_t_7 != 0);
if (__pyx_t_5) {
@@ -60972,9 +60289,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* tsecs = time*60.
* elif unit in hr_units:
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_min_units); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_min_units); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5231, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5231, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_7 = (__pyx_t_5 != 0);
if (__pyx_t_7) {
@@ -60986,7 +60303,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* elif unit in hr_units:
* tsecs = time*3600.
*/
- __pyx_t_4 = PyNumber_Multiply(__pyx_v_time, __pyx_float_60_); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5232; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Multiply(__pyx_v_time, __pyx_float_60_); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5232, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_tsecs, __pyx_t_4);
__pyx_t_4 = 0;
@@ -61008,9 +60325,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* tsecs = time*3600.
* elif unit in day_units:
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_hr_units); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5233; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_hr_units); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5233, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5233; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5233, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_5 = (__pyx_t_7 != 0);
if (__pyx_t_5) {
@@ -61022,7 +60339,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* elif unit in day_units:
* tsecs = time*86400.
*/
- __pyx_t_4 = PyNumber_Multiply(__pyx_v_time, __pyx_float_3600_); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5234; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Multiply(__pyx_v_time, __pyx_float_3600_); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5234, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_tsecs, __pyx_t_4);
__pyx_t_4 = 0;
@@ -61044,9 +60361,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* tsecs = time*86400.
* else:
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_day_units); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_day_units); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5235, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_v_unit, __pyx_t_4, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 5235, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_7 = (__pyx_t_5 != 0);
if (__pyx_t_7) {
@@ -61058,7 +60375,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* else:
* raise ValueError('unsupported time units')
*/
- __pyx_t_4 = PyNumber_Multiply(__pyx_v_time, __pyx_float_86400_); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5236; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Multiply(__pyx_v_time, __pyx_float_86400_); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5236, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_tsecs, __pyx_t_4);
__pyx_t_4 = 0;
@@ -61081,11 +60398,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* days = tsecs // 86400.
*/
/*else*/ {
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__111, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__104, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5238, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5238, __pyx_L1_error)
}
__pyx_L33:;
@@ -61096,7 +60413,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* msecsd = tsecs*1.e6 - days*86400.*1.e6
* secs = msecsd // 1.e6
*/
- __pyx_t_4 = PyNumber_FloorDivide(__pyx_v_tsecs, __pyx_float_86400_); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5240; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_FloorDivide(__pyx_v_tsecs, __pyx_float_86400_); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5240, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_XDECREF_SET(__pyx_v_days, __pyx_t_4);
__pyx_t_4 = 0;
@@ -61108,14 +60425,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* secs = msecsd // 1.e6
* msecs = numpy.round(msecsd - secs*1.e6)
*/
- __pyx_t_4 = PyNumber_Multiply(__pyx_v_tsecs, __pyx_float_1_e6); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5241; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyNumber_Multiply(__pyx_v_tsecs, __pyx_float_1_e6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5241, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyNumber_Multiply(__pyx_v_days, __pyx_float_86400_); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5241; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Multiply(__pyx_v_days, __pyx_float_86400_); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5241, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = PyNumber_Multiply(__pyx_t_3, __pyx_float_1_e6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5241; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Multiply(__pyx_t_3, __pyx_float_1_e6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5241, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5241; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_Subtract(__pyx_t_4, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5241, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -61129,7 +60446,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* msecs = numpy.round(msecsd - secs*1.e6)
* td = timedelta(days=days,seconds=secs,microseconds=msecs)
*/
- __pyx_t_3 = PyNumber_FloorDivide(__pyx_v_msecsd, __pyx_float_1_e6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5242; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyNumber_FloorDivide(__pyx_v_msecsd, __pyx_float_1_e6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5242, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_XDECREF_SET(__pyx_v_secs, __pyx_t_3);
__pyx_t_3 = 0;
@@ -61141,14 +60458,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* td = timedelta(days=days,seconds=secs,microseconds=msecs)
* # add time delta to base date.
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_round); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_round); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_Multiply(__pyx_v_secs, __pyx_float_1_e6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Multiply(__pyx_v_secs, __pyx_float_1_e6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_14 = PyNumber_Subtract(__pyx_v_msecsd, __pyx_t_1); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyNumber_Subtract(__pyx_v_msecsd, __pyx_t_1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -61162,17 +60479,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_1) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_14); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_14); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5243, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
- __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(1+1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_GIVEREF(__pyx_t_14);
PyTuple_SET_ITEM(__pyx_t_15, 0+1, __pyx_t_14);
__pyx_t_14 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5243; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
}
@@ -61187,14 +60504,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* # add time delta to base date.
* date = basedate + td
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_timedelta); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_timedelta); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5244, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5244, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_days, __pyx_v_days) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_seconds, __pyx_v_secs) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_microseconds, __pyx_v_msecs) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5244; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_days, __pyx_v_days) < 0) __PYX_ERR(0, 5244, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_seconds, __pyx_v_secs) < 0) __PYX_ERR(0, 5244, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_microseconds, __pyx_v_msecs) < 0) __PYX_ERR(0, 5244, __pyx_L1_error)
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5244, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -61208,7 +60525,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* dates.append(date)
* if isscalar:
*/
- __pyx_t_15 = PyNumber_Add(__pyx_v_basedate, __pyx_v_td); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5246; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyNumber_Add(__pyx_v_basedate, __pyx_v_td); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5246, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_XDECREF_SET(__pyx_v_date, __pyx_t_15);
__pyx_t_15 = 0;
@@ -61220,7 +60537,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* if isscalar:
* return dates[0]
*/
- __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_dates, __pyx_v_date); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5247; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_dates, __pyx_v_date); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 5247, __pyx_L1_error)
}
__pyx_L30:;
@@ -61252,7 +60569,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* return numpy.reshape(numpy.array(dates), shape)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_dates, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5249; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_dates, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
@@ -61276,14 +60593,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_reshape); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_reshape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_array); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -61297,21 +60614,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_3) {
- __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_v_dates); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_14, __pyx_v_dates); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
} else {
- __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_dates);
__Pyx_GIVEREF(__pyx_v_dates);
PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_v_dates);
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_1, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_1, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
- if (unlikely(!__pyx_v_shape)) { __Pyx_RaiseUnboundLocalError("shape"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
+ if (unlikely(!__pyx_v_shape)) { __Pyx_RaiseUnboundLocalError("shape"); __PYX_ERR(0, 5251, __pyx_L1_error) }
__pyx_t_14 = NULL;
__pyx_t_11 = 0;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
@@ -61324,7 +60641,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
__pyx_t_11 = 1;
}
}
- __pyx_t_1 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (__pyx_t_14) {
__Pyx_GIVEREF(__pyx_t_14); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_14); __pyx_t_14 = NULL;
@@ -61335,7 +60652,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
__Pyx_GIVEREF(__pyx_v_shape);
PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_11, __pyx_v_shape);
__pyx_t_15 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5251; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5251, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -61361,20 +60678,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
*
*/
/*else*/ {
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_utime); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_utime); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_units);
__Pyx_GIVEREF(__pyx_v_units);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_units);
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_calendar, __pyx_v_calendar) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5253; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_calendar, __pyx_v_calendar) < 0) __PYX_ERR(0, 5253, __pyx_L1_error)
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -61390,7 +60707,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
* def date2index(dates, nctime, calendar=None, select='exact'):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cdftime, __pyx_n_s_num2date); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_cdftime, __pyx_n_s_num2date); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -61403,16 +60720,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_18num2date(CYTHON_UNUSED PyObject *
}
}
if (!__pyx_t_2) {
- __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_times); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_times); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_times);
__Pyx_GIVEREF(__pyx_v_times);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_times);
- __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5254; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5254, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -61480,9 +60797,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_21date2index(PyObject *__pyx_self,
PyObject *__pyx_v_nctime = 0;
PyObject *__pyx_v_calendar = 0;
PyObject *__pyx_v_select = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("date2index (wrapper)", 0);
@@ -61510,7 +60824,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_21date2index(PyObject *__pyx_self,
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nctime)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("date2index", 0, 2, 4, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5256; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("date2index", 0, 2, 4, 1); __PYX_ERR(0, 5256, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
@@ -61524,7 +60838,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_21date2index(PyObject *__pyx_self,
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "date2index") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5256; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "date2index") < 0)) __PYX_ERR(0, 5256, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -61543,7 +60857,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_21date2index(PyObject *__pyx_self,
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("date2index", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5256; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("date2index", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5256, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.date2index", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -61575,9 +60889,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
int __pyx_t_11;
int __pyx_t_12;
Py_ssize_t __pyx_t_13;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("date2index", 0);
__Pyx_INCREF(__pyx_v_calendar);
@@ -61589,6 +60900,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* except AttributeError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_1);
__Pyx_XGOTREF(__pyx_t_2);
@@ -61602,7 +60915,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* except AttributeError:
* raise AttributeError("netcdf time variable is missing a 'units' attribute")
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_nctime, __pyx_n_s_units); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5288; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_nctime, __pyx_n_s_units); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5288, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -61619,6 +60932,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L10_try_end;
__pyx_L3_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "netCDF4/_netCDF4.pyx":5289
@@ -61628,10 +60942,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* raise AttributeError("netcdf time variable is missing a 'units' attribute")
* if calendar == None:
*/
- __pyx_t_5 = PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
+ __pyx_t_5 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_AttributeError);
if (__pyx_t_5) {
__Pyx_AddTraceback("netCDF4._netCDF4.date2index", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5289; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;}
+ if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(0, 5289, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_7);
@@ -61643,11 +60957,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* if calendar == None:
* calendar = getattr(nctime, 'calendar', 'standard')
*/
- __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__112, NULL); if (unlikely(!__pyx_t_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5290; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;}
+ __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_tuple__105, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 5290, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5290; __pyx_clineno = __LINE__; goto __pyx_L5_except_error;}
+ __PYX_ERR(0, 5290, __pyx_L5_except_error)
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
@@ -61659,6 +60973,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* nctime.units
* except AttributeError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
@@ -61674,8 +60989,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* calendar = getattr(nctime, 'calendar', 'standard')
* calendar = calendar.lower()
*/
- __pyx_t_7 = PyObject_RichCompare(__pyx_v_calendar, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5291; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5291; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_RichCompare(__pyx_v_calendar, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5291, __pyx_L1_error)
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 5291, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_9) {
@@ -61686,7 +61001,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* calendar = calendar.lower()
* basedate = _dateparse(nctime.units)
*/
- __pyx_t_7 = __Pyx_GetAttr3(__pyx_v_nctime, __pyx_n_s_calendar, __pyx_n_s_standard); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetAttr3(__pyx_v_nctime, __pyx_n_s_calendar, __pyx_n_s_standard); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5292, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF_SET(__pyx_v_calendar, __pyx_t_7);
__pyx_t_7 = 0;
@@ -61707,7 +61022,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* basedate = _dateparse(nctime.units)
* # real-world calendars limited to positive reference years.
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_calendar, __pyx_n_s_lower); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5293; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_calendar, __pyx_n_s_lower); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5293, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -61720,10 +61035,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
}
}
if (__pyx_t_4) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5293; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5293, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5293; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5293, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -61737,9 +61052,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* # real-world calendars limited to positive reference years.
* if calendar in ['julian', 'standard', 'gregorian', 'proleptic_gregorian']:
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_dateparse); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5294; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_dateparse); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5294, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_nctime, __pyx_n_s_units); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5294; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_nctime, __pyx_n_s_units); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5294, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_8 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_6))) {
@@ -61752,17 +61067,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
}
}
if (!__pyx_t_8) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5294; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5294, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5294; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5294, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5294; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5294, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
@@ -61779,25 +61094,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
*/
__Pyx_INCREF(__pyx_v_calendar);
__pyx_t_7 = __pyx_v_calendar;
- __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_julian, Py_EQ)); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5296; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_julian, Py_EQ)); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5296, __pyx_L1_error)
if (!__pyx_t_11) {
} else {
__pyx_t_9 = __pyx_t_11;
goto __pyx_L15_bool_binop_done;
}
- __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5296; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5296, __pyx_L1_error)
if (!__pyx_t_11) {
} else {
__pyx_t_9 = __pyx_t_11;
goto __pyx_L15_bool_binop_done;
}
- __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5296; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5296, __pyx_L1_error)
if (!__pyx_t_11) {
} else {
__pyx_t_9 = __pyx_t_11;
goto __pyx_L15_bool_binop_done;
}
- __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5296; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = (__Pyx_PyString_Equals(__pyx_t_7, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5296, __pyx_L1_error)
__pyx_t_9 = __pyx_t_11;
__pyx_L15_bool_binop_done:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -61811,12 +61126,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* msg='zero not allowed as a reference year, does not exist in Julian or Gregorian calendars'
* raise ValueError(msg)
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5297; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5297, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5297; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyInt_EqObjC(__pyx_t_7, __pyx_int_0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5297, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5297; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5297, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_11) {
@@ -61837,17 +61152,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* elif basedate.year < 0:
* msg='negative reference year in time units, must be >= 1'
*/
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5299; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5299, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_msg);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5299; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5299, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5299; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5299, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5297
* # real-world calendars limited to positive reference years.
@@ -61865,11 +61180,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* msg='negative reference year in time units, must be >= 1'
* raise ValueError(msg)
*/
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5300, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5300, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5300, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_11) {
@@ -61890,17 +61205,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
*
* if (calendar == 'proleptic_gregorian' and basedate.year >= MINYEAR) or \
*/
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5302, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_msg);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5302, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5302; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5302, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5300
* msg='zero not allowed as a reference year, does not exist in Julian or Gregorian calendars'
@@ -61927,19 +61242,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* (calendar in ['gregorian','standard'] and basedate > gregorian):
* # use python datetime
*/
- __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_calendar, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = (__Pyx_PyString_Equals(__pyx_v_calendar, __pyx_n_s_proleptic_gregorian, Py_EQ)); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 5304, __pyx_L1_error)
if (!__pyx_t_9) {
goto __pyx_L22_next_or;
} else {
}
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_basedate, __pyx_n_s_year); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5304, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5304, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = PyObject_RichCompare(__pyx_t_7, __pyx_t_6, Py_GE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyObject_RichCompare(__pyx_t_7, __pyx_t_6, Py_GE); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5304, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_9 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 5304, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
if (!__pyx_t_9) {
} else {
@@ -61957,13 +61272,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
*/
__Pyx_INCREF(__pyx_v_calendar);
__pyx_t_10 = __pyx_v_calendar;
- __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_10, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5305; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_10, __pyx_n_s_gregorian, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 5305, __pyx_L1_error)
if (!__pyx_t_12) {
} else {
__pyx_t_9 = __pyx_t_12;
goto __pyx_L25_bool_binop_done;
}
- __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_10, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5305; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = (__Pyx_PyString_Equals(__pyx_t_10, __pyx_n_s_standard, Py_EQ)); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 5305, __pyx_L1_error)
__pyx_t_9 = __pyx_t_12;
__pyx_L25_bool_binop_done:;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
@@ -61973,11 +61288,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
__pyx_t_11 = __pyx_t_12;
goto __pyx_L21_bool_binop_done;
}
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_gregorian); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5305; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_gregorian); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5305, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_6 = PyObject_RichCompare(__pyx_v_basedate, __pyx_t_10, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5305; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_RichCompare(__pyx_v_basedate, __pyx_t_10, Py_GT); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5305, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_12 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5305; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_12 < 0)) __PYX_ERR(0, 5305, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_11 = __pyx_t_12;
__pyx_L21_bool_binop_done:;
@@ -61998,11 +61313,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* return netcdftime.time2index(times, nctime, calendar, select)
* else: # use netcdftime module for other cases
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_date2num); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_date2num); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5307, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_nctime, __pyx_n_s_units); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_nctime, __pyx_n_s_units); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5307, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5307, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_v_dates);
__Pyx_GIVEREF(__pyx_v_dates);
@@ -62010,10 +61325,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_10);
__pyx_t_10 = 0;
- __pyx_t_10 = PyDict_New(); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyDict_New(); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5307, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_calendar, __pyx_v_calendar) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5307; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_10, __pyx_n_s_calendar, __pyx_v_calendar) < 0) __PYX_ERR(0, 5307, __pyx_L1_error)
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, __pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5307, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -62029,9 +61344,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
* return netcdftime.date2index(dates, nctime, calendar, select)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5308; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5308, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_time2index); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5308; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_time2index); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5308, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = NULL;
@@ -62046,7 +61361,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
__pyx_t_13 = 1;
}
}
- __pyx_t_6 = PyTuple_New(4+__pyx_t_13); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5308; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(4+__pyx_t_13); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5308, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_10) {
__Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_10); __pyx_t_10 = NULL;
@@ -62063,7 +61378,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
__Pyx_INCREF(__pyx_v_select);
__Pyx_GIVEREF(__pyx_v_select);
PyTuple_SET_ITEM(__pyx_t_6, 3+__pyx_t_13, __pyx_v_select);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5308; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5308, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -62089,9 +61404,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5310; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdftime); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5310, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_date2index); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5310; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_date2index); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5310, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = NULL;
@@ -62106,7 +61421,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
__pyx_t_13 = 1;
}
}
- __pyx_t_10 = PyTuple_New(4+__pyx_t_13); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5310; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(4+__pyx_t_13); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5310, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -62123,7 +61438,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_20date2index(CYTHON_UNUSED PyObject
__Pyx_INCREF(__pyx_v_select);
__Pyx_GIVEREF(__pyx_v_select);
PyTuple_SET_ITEM(__pyx_t_10, 3+__pyx_t_13, __pyx_v_select);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5310; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5310, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -62172,12 +61487,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_12__defaults__(CYTHON_UN
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__defaults__", 0);
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5342, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)Py_False));
__Pyx_GIVEREF(((PyObject *)Py_False));
@@ -62188,7 +61500,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_12__defaults__(CYTHON_UN
__Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_exclude);
__Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_exclude);
PyTuple_SET_ITEM(__pyx_t_1, 2, __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_exclude);
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5342, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
@@ -62222,9 +61534,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_1__init__(PyObject *__py
PyObject *__pyx_v_check = 0;
PyObject *__pyx_v_aggdim = 0;
PyObject *__pyx_v_exclude = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -62255,7 +61564,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_1__init__(PyObject *__py
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_files)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, 1); __PYX_ERR(0, 5342, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
@@ -62274,7 +61583,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_1__init__(PyObject *__py
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 5342, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -62295,7 +61604,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_1__init__(PyObject *__py
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5342, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.MFDataset.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -62359,9 +61668,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject *__pyx_t_15 = NULL;
Py_ssize_t __pyx_t_16;
Py_ssize_t __pyx_t_17;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
__Pyx_INCREF(__pyx_v_files);
@@ -62383,12 +61689,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* msg='cannot using file globbing for remote (OPeNDAP) datasets'
* raise ValueError(msg)
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_files, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5376; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_files, __pyx_n_s_startswith); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__113, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5376; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__106, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5376; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5376, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_2) {
@@ -62409,17 +61715,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* else:
* files = sorted(glob(files))
*/
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_msg);
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5378; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5378, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5376
* # can be used like a CDF instance.
@@ -62438,7 +61744,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* master = files[0]
*/
/*else*/ {
- __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_glob); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5380; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_glob); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_5))) {
@@ -62451,26 +61757,26 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (!__pyx_t_6) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_files); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5380; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_files); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5380; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_files);
__Pyx_GIVEREF(__pyx_v_files);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_files);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5380; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_5 = PySequence_List(__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5380; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_List(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_3 = ((PyObject*)__pyx_t_5);
__pyx_t_5 = 0;
- __pyx_t_8 = PyList_Sort(__pyx_t_3); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5380; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = PyList_Sort(__pyx_t_3); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5380, __pyx_L1_error)
__Pyx_DECREF_SET(__pyx_v_files, __pyx_t_3);
__pyx_t_3 = 0;
}
@@ -62491,7 +61797,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Open the master again, this time as a classic CDF instance. This will avoid
*/
- __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_files, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5382; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_GetItemInt(__pyx_v_files, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_master = __pyx_t_3;
__pyx_t_3 = 0;
@@ -62503,12 +61809,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* # copy attributes from master.
* for name, value in cdfm.__dict__.items():
*/
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5386; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_master);
__Pyx_GIVEREF(__pyx_v_master);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_master);
- __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset), __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5386; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset), __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_cdfm = ((struct __pyx_obj_7netCDF4_8_netCDF4_Dataset *)__pyx_t_5);
@@ -62521,9 +61827,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self.__dict__[name] = value
*
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cdfm), __pyx_n_s_dict); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_cdfm), __pyx_n_s_dict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_items); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_items); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -62537,10 +61843,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_3) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5388, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -62548,9 +61854,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__pyx_t_4 = __pyx_t_5; __Pyx_INCREF(__pyx_t_4); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5388, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
for (;;) {
@@ -62558,17 +61864,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_5); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_5); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5388, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_5); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_5); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5388, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
}
@@ -62578,7 +61884,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5388, __pyx_L1_error)
}
break;
}
@@ -62594,7 +61900,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5388, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -62607,15 +61913,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_7);
#else
- __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_6 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext;
@@ -62623,7 +61929,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_GOTREF(__pyx_t_3);
index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_6); if (unlikely(!__pyx_t_7)) goto __pyx_L7_unpacking_failed;
__Pyx_GOTREF(__pyx_t_7);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_6), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_6), 2) < 0) __PYX_ERR(0, 5388, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L8_unpacking_done;
@@ -62631,7 +61937,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5388; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5388, __pyx_L1_error)
__pyx_L8_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_3);
@@ -62646,9 +61952,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Make sure the master defines a dim with name aggdim,
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5389; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5389, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- if (unlikely(PyObject_SetItem(__pyx_t_5, __pyx_v_name, __pyx_v_value) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5389; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_5, __pyx_v_name, __pyx_v_value) < 0)) __PYX_ERR(0, 5389, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "netCDF4/_netCDF4.pyx":5388
@@ -62678,7 +61984,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* if aggdim is None:
* if dim.isunlimited():
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_cdfm->dimensions, __pyx_n_s_items); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_cdfm->dimensions, __pyx_n_s_items); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -62691,10 +61997,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_7) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5394, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5394, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -62702,9 +62008,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_10 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5394, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
for (;;) {
@@ -62712,17 +62018,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_5))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5394, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5394, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -62732,7 +62038,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5394, __pyx_L1_error)
}
break;
}
@@ -62748,7 +62054,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5394, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -62761,15 +62067,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_3);
#else
- __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext;
@@ -62777,7 +62083,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_GOTREF(__pyx_t_7);
index = 1; __pyx_t_3 = __pyx_t_11(__pyx_t_6); if (unlikely(!__pyx_t_3)) goto __pyx_L11_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_6), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_6), 2) < 0) __PYX_ERR(0, 5394, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L12_unpacking_done;
@@ -62785,7 +62091,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5394; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5394, __pyx_L1_error)
__pyx_L12_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_7);
@@ -62811,7 +62117,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* aggDimId = dim
* aggDimName = dimname
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5396, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -62824,14 +62130,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_7) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5396, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5396, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5396; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 5396, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_1) {
@@ -62882,8 +62188,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* aggDimName = dimname
*/
/*else*/ {
- __pyx_t_4 = PyObject_RichCompare(__pyx_v_dimname, __pyx_v_aggdim, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5400; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5400; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_dimname, __pyx_v_aggdim, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5400, __pyx_L1_error)
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 5400, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_1) {
@@ -62946,19 +62252,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Get info on all aggregation variables defined in the master.
*/
- __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_master_dataset_s_does_not_have_a, __pyx_v_master); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5404; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_master_dataset_s_does_not_have_a, __pyx_v_master); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5404; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__pyx_t_5 = 0;
- __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5404; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5404; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5404, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5403
* aggDimId = dim
@@ -62976,7 +62282,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* for vName,v in cdfm.variables.items():
* # skip variables specified in exclude list.
*/
- __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5408; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5408, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_v_masterRecVar = ((PyObject*)__pyx_t_5);
__pyx_t_5 = 0;
@@ -62988,7 +62294,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* # skip variables specified in exclude list.
* if vName in exclude: continue
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_cdfm->variables, __pyx_n_s_items); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_cdfm->variables, __pyx_n_s_items); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -63001,10 +62307,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_3) {
- __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5409, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5409, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -63012,9 +62318,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__pyx_t_4 = __pyx_t_5; __Pyx_INCREF(__pyx_t_4); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5409, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
for (;;) {
@@ -63022,17 +62328,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_5); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_5); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5409, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_5); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_5); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5409, __pyx_L1_error)
#else
- __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
}
@@ -63042,7 +62348,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5409, __pyx_L1_error)
}
break;
}
@@ -63058,7 +62364,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5409, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -63071,15 +62377,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_7);
#else
- __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_6 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5409, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_6)->tp_iternext;
@@ -63087,7 +62393,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_GOTREF(__pyx_t_3);
index = 1; __pyx_t_7 = __pyx_t_11(__pyx_t_6); if (unlikely(!__pyx_t_7)) goto __pyx_L19_unpacking_failed;
__Pyx_GOTREF(__pyx_t_7);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_6), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_6), 2) < 0) __PYX_ERR(0, 5409, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L20_unpacking_done;
@@ -63095,7 +62401,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5409; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5409, __pyx_L1_error)
__pyx_L20_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_vName, __pyx_t_3);
@@ -63110,7 +62416,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* dims = v.dimensions
* shape = v.shape
*/
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_vName, __pyx_v_exclude, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5411; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_vName, __pyx_v_exclude, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5411, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
goto __pyx_L17_continue;
@@ -63123,7 +62429,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* shape = v.shape
* dtype = v.dtype
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5412; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XDECREF_SET(__pyx_v_dims, __pyx_t_5);
__pyx_t_5 = 0;
@@ -63135,7 +62441,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* dtype = v.dtype
* # Be carefull: we may deal with a scalar (dimensionless) variable.
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5413; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5413, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XDECREF_SET(__pyx_v_shape, __pyx_t_5);
__pyx_t_5 = 0;
@@ -63147,7 +62453,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* # Be carefull: we may deal with a scalar (dimensionless) variable.
* # Unlimited dimension always occupies index 0.
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5414; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_dtype); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5414, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XDECREF_SET(__pyx_v_dtype, __pyx_t_5);
__pyx_t_5 = 0;
@@ -63159,19 +62465,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* masterRecVar[vName] = (dims, shape, dtype)
* if len(masterRecVar) == 0:
*/
- __pyx_t_12 = PyObject_Length(__pyx_v_dims); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5417; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_Length(__pyx_v_dims); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 5417, __pyx_L1_error)
__pyx_t_2 = ((__pyx_t_12 > 0) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L23_bool_binop_done;
}
- if (unlikely(!__pyx_v_aggDimName)) { __Pyx_RaiseUnboundLocalError("aggDimName"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5417; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_dims, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_5 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5417; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ if (unlikely(!__pyx_v_aggDimName)) { __Pyx_RaiseUnboundLocalError("aggDimName"); __PYX_ERR(0, 5417, __pyx_L1_error) }
+ __pyx_t_5 = __Pyx_GetItemInt(__pyx_v_dims, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5417, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = PyObject_RichCompare(__pyx_v_aggDimName, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5417; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_RichCompare(__pyx_v_aggDimName, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5417, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5417; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5417, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L23_bool_binop_done:;
@@ -63184,7 +62490,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* if len(masterRecVar) == 0:
* raise IOError("master dataset %s does not have any variables to aggregate" % master)
*/
- __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5418; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5418, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_v_dims);
__Pyx_GIVEREF(__pyx_v_dims);
@@ -63195,7 +62501,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_v_dtype);
__Pyx_GIVEREF(__pyx_v_dtype);
PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_dtype);
- if (unlikely(PyDict_SetItem(__pyx_v_masterRecVar, __pyx_v_vName, __pyx_t_7) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5418; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItem(__pyx_v_masterRecVar, __pyx_v_vName, __pyx_t_7) < 0)) __PYX_ERR(0, 5418, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5417
@@ -63225,7 +62531,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* raise IOError("master dataset %s does not have any variables to aggregate" % master)
*
*/
- __pyx_t_9 = PyDict_Size(__pyx_v_masterRecVar); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5419; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyDict_Size(__pyx_v_masterRecVar); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 5419, __pyx_L1_error)
__pyx_t_1 = ((__pyx_t_9 == 0) != 0);
if (__pyx_t_1) {
@@ -63236,19 +62542,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Create the following:
*/
- __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_master_dataset_s_does_not_have_a_2, __pyx_v_master); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_master_dataset_s_does_not_have_a_2, __pyx_v_master); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5420, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5420, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5420, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5420; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5420, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5419
* if (len(dims) > 0 and aggDimName == dims[0]):
@@ -63266,7 +62572,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._cdf = cdf # Store this now, because dim() method needs it
* cdfVLen = [len(aggDimId)]
*/
- __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5428; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5428, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(((PyObject *)__pyx_v_cdfm));
__Pyx_GIVEREF(((PyObject *)__pyx_v_cdfm));
@@ -63281,7 +62587,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* cdfVLen = [len(aggDimId)]
* cdfRecVar = {}
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_cdf, __pyx_v_cdf) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5429; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_cdf, __pyx_v_cdf) < 0) __PYX_ERR(0, 5429, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5430
* cdf = [cdfm]
@@ -63290,10 +62596,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* cdfRecVar = {}
* for v in masterRecVar.keys():
*/
- __pyx_t_9 = PyObject_Length(__pyx_v_aggDimId); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5430; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5430; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_Length(__pyx_v_aggDimId); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 5430, __pyx_L1_error)
+ __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5430, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5430; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5430, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_4);
PyList_SET_ITEM(__pyx_t_7, 0, __pyx_t_4);
@@ -63308,7 +62614,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* for v in masterRecVar.keys():
* cdfRecVar[v] = [cdfm.variables[v]]
*/
- __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5431; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5431, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_v_cdfRecVar = ((PyObject*)__pyx_t_7);
__pyx_t_7 = 0;
@@ -63320,15 +62626,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* cdfRecVar[v] = [cdfm.variables[v]]
*
*/
- __pyx_t_7 = __Pyx_PyDict_Keys(__pyx_v_masterRecVar); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5432; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyDict_Keys(__pyx_v_masterRecVar); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) {
__pyx_t_4 = __pyx_t_7; __Pyx_INCREF(__pyx_t_4); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5432; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5432; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5432, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -63336,17 +62642,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5432; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5432, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5432; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5432; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5432, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5432; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -63356,7 +62662,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5432; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5432, __pyx_L1_error)
}
break;
}
@@ -63372,14 +62678,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Open each remaining file in read-only mode.
*/
- __pyx_t_7 = PyObject_GetItem(__pyx_v_cdfm->variables, __pyx_v_v); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5433; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = PyObject_GetItem(__pyx_v_cdfm->variables, __pyx_v_v); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5433, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5433; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5433, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_7);
PyList_SET_ITEM(__pyx_t_5, 0, __pyx_t_7);
__pyx_t_7 = 0;
- if (unlikely(PyDict_SetItem(__pyx_v_cdfRecVar, __pyx_v_v, __pyx_t_5) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5433; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItem(__pyx_v_cdfRecVar, __pyx_v_v, __pyx_t_5) < 0)) __PYX_ERR(0, 5433, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "netCDF4/_netCDF4.pyx":5432
@@ -63399,15 +62705,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* part = Dataset(f)
* varInfo = part.variables
*/
- __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_files, 1, 0, NULL, NULL, &__pyx_slice__114, 1, 0, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetSlice(__pyx_v_files, 1, 0, NULL, NULL, &__pyx_slice__107, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5438, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
__pyx_t_5 = __pyx_t_4; __Pyx_INCREF(__pyx_t_5); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5438, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_10 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5438, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
for (;;) {
@@ -63415,17 +62721,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_5))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5438, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5438, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5438, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_5, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5438, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -63435,7 +62741,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5438, __pyx_L1_error)
}
break;
}
@@ -63451,12 +62757,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* varInfo = part.variables
* for v in masterRecVar.keys():
*/
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5439, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_f);
__Pyx_GIVEREF(__pyx_v_f);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_f);
- __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset), __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5439; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset), __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5439, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF_SET(__pyx_v_part, ((struct __pyx_obj_7netCDF4_8_netCDF4_Dataset *)__pyx_t_7));
@@ -63481,15 +62787,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* if check:
* # Make sure master rec var is also defined here.
*/
- __pyx_t_7 = __Pyx_PyDict_Keys(__pyx_v_masterRecVar); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyDict_Keys(__pyx_v_masterRecVar); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5441, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) {
__pyx_t_4 = __pyx_t_7; __Pyx_INCREF(__pyx_t_4); __pyx_t_12 = 0;
__pyx_t_13 = NULL;
} else {
- __pyx_t_12 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5441, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_13 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5441, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -63497,17 +62803,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_12 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_12); __Pyx_INCREF(__pyx_t_7); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_12); __Pyx_INCREF(__pyx_t_7); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 5441, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5441, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_12 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_12); __Pyx_INCREF(__pyx_t_7); __pyx_t_12++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_12); __Pyx_INCREF(__pyx_t_7); __pyx_t_12++; if (unlikely(0 < 0)) __PYX_ERR(0, 5441, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_12); __pyx_t_12++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5441, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -63517,7 +62823,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5441; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5441, __pyx_L1_error)
}
break;
}
@@ -63533,7 +62839,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* # Make sure master rec var is also defined here.
* if v not in varInfo.keys():
*/
- __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5442; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_check); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 5442, __pyx_L1_error)
if (__pyx_t_1) {
/* "netCDF4/_netCDF4.pyx":5444
@@ -63543,7 +62849,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* raise IOError("aggregation variable %s not defined in %s" % (v, f))
*
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_varInfo, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5444; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_varInfo, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5444, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -63556,14 +62862,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_6) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5444; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5444, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5444; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5444, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_v, __pyx_t_7, Py_NE)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5444; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PySequence_ContainsTF(__pyx_v_v, __pyx_t_7, Py_NE)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 5444, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
@@ -63575,7 +62881,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* #if not vInst.dimensions[0] != aggDimName:
*/
- __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5445, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_v_v);
__Pyx_GIVEREF(__pyx_v_v);
@@ -63583,20 +62889,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_v_f);
__Pyx_GIVEREF(__pyx_v_f);
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_f);
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_aggregation_variable_s_not_defin, __pyx_t_7); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_aggregation_variable_s_not_defin, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5445, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5445, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5445, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5445; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5445, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5444
* if check:
@@ -63614,9 +62920,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* extDims = varInfo[v].dimensions
* extShape = varInfo[v].shape
*/
- __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_masterRecVar, __pyx_v_v); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_masterRecVar, __pyx_v_v); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_3, 0, 3, NULL, NULL, &__pyx_slice__115, 0, 1, 1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_3, 0, 3, NULL, NULL, &__pyx_slice__108, 0, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if ((likely(PyTuple_CheckExact(__pyx_t_7))) || (PyList_CheckExact(__pyx_t_7))) {
@@ -63629,7 +62935,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (unlikely(size != 3)) {
if (size > 3) __Pyx_RaiseTooManyValuesError(3);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5449, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -63645,17 +62951,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_14);
#else
- __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_14 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PySequence_ITEM(sequence, 2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
#endif
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_15 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5449, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_15)->tp_iternext;
@@ -63665,7 +62971,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_GOTREF(__pyx_t_6);
index = 2; __pyx_t_14 = __pyx_t_11(__pyx_t_15); if (unlikely(!__pyx_t_14)) goto __pyx_L34_unpacking_failed;
__Pyx_GOTREF(__pyx_t_14);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_15), 3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_15), 3) < 0) __PYX_ERR(0, 5449, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
goto __pyx_L35_unpacking_done;
@@ -63673,7 +62979,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5449, __pyx_L1_error)
__pyx_L35_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_masterDims, __pyx_t_3);
@@ -63690,9 +62996,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* extShape = varInfo[v].shape
* extType = varInfo[v].dtype
*/
- __pyx_t_7 = PyObject_GetItem(__pyx_v_varInfo, __pyx_v_v); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5450; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = PyObject_GetItem(__pyx_v_varInfo, __pyx_v_v); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5450; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF_SET(__pyx_v_extDims, __pyx_t_14);
@@ -63705,9 +63011,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* extType = varInfo[v].dtype
* # Check that dimension names are identical.
*/
- __pyx_t_14 = PyObject_GetItem(__pyx_v_varInfo, __pyx_v_v); if (unlikely(__pyx_t_14 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5451; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_14 = PyObject_GetItem(__pyx_v_varInfo, __pyx_v_v); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5451, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5451; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_14, __pyx_n_s_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5451, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_XDECREF_SET(__pyx_v_extShape, __pyx_t_7);
@@ -63720,9 +63026,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* # Check that dimension names are identical.
* if masterDims != extDims:
*/
- __pyx_t_7 = PyObject_GetItem(__pyx_v_varInfo, __pyx_v_v); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5452; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = PyObject_GetItem(__pyx_v_varInfo, __pyx_v_v); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_dtype); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5452; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_dtype); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF_SET(__pyx_v_extType, __pyx_t_14);
@@ -63735,8 +63041,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* raise IOError("variable %s : dimensions mismatch between "
* "master %s (%s) and extension %s (%s)" %
*/
- __pyx_t_14 = PyObject_RichCompare(__pyx_v_masterDims, __pyx_v_extDims, Py_NE); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5454; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_14); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5454; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyObject_RichCompare(__pyx_v_masterDims, __pyx_v_extDims, Py_NE); __Pyx_XGOTREF(__pyx_t_14); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5454, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_14); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5454, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
if (__pyx_t_2) {
@@ -63747,7 +63053,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Check that the ranks are identical, and the dimension lengths are
*/
- __pyx_t_14 = PyTuple_New(5); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5457; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyTuple_New(5); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5457, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_INCREF(__pyx_v_v);
__Pyx_GIVEREF(__pyx_v_v);
@@ -63772,7 +63078,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* (v, master, masterDims, f, extDims))
*
*/
- __pyx_t_7 = __Pyx_PyString_Format(__pyx_kp_s_variable_s_dimensions_mismatch_b, __pyx_t_14); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5456; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyString_Format(__pyx_kp_s_variable_s_dimensions_mismatch_b, __pyx_t_14); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
@@ -63783,17 +63089,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* "master %s (%s) and extension %s (%s)" %
* (v, master, masterDims, f, extDims))
*/
- __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyTuple_New(1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5455, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_7);
__pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_14, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_14, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5455, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5455; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5455, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5454
* extType = varInfo[v].dtype
@@ -63811,8 +63117,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* raise IOError("variable %s : rank mismatch between "
* "master %s (%s) and extension %s (%s)" %
*/
- __pyx_t_16 = PyObject_Length(__pyx_v_masterShape); if (unlikely(__pyx_t_16 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_17 = PyObject_Length(__pyx_v_extShape); if (unlikely(__pyx_t_17 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5462; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_16 = PyObject_Length(__pyx_v_masterShape); if (unlikely(__pyx_t_16 == -1)) __PYX_ERR(0, 5462, __pyx_L1_error)
+ __pyx_t_17 = PyObject_Length(__pyx_v_extShape); if (unlikely(__pyx_t_17 == -1)) __PYX_ERR(0, 5462, __pyx_L1_error)
__pyx_t_2 = ((__pyx_t_16 != __pyx_t_17) != 0);
if (__pyx_t_2) {
@@ -63823,13 +63129,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* if masterShape[1:] != extShape[1:]:
* raise IOError("variable %s : shape mismatch between "
*/
- __pyx_t_17 = PyObject_Length(__pyx_v_masterShape); if (unlikely(__pyx_t_17 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_17); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_17 = PyObject_Length(__pyx_v_masterShape); if (unlikely(__pyx_t_17 == -1)) __PYX_ERR(0, 5465, __pyx_L1_error)
+ __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_17); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5465, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_17 = PyObject_Length(__pyx_v_extShape); if (unlikely(__pyx_t_17 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_14 = PyInt_FromSsize_t(__pyx_t_17); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_17 = PyObject_Length(__pyx_v_extShape); if (unlikely(__pyx_t_17 == -1)) __PYX_ERR(0, 5465, __pyx_L1_error)
+ __pyx_t_14 = PyInt_FromSsize_t(__pyx_t_17); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5465, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
- __pyx_t_6 = PyTuple_New(5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5465, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_v);
__Pyx_GIVEREF(__pyx_v_v);
@@ -63854,7 +63160,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* (v, master, len(masterShape), f, len(extShape)))
* if masterShape[1:] != extShape[1:]:
*/
- __pyx_t_14 = __Pyx_PyString_Format(__pyx_kp_s_variable_s_rank_mismatch_between, __pyx_t_6); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5464; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyString_Format(__pyx_kp_s_variable_s_rank_mismatch_between, __pyx_t_6); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5464, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -63865,17 +63171,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* "master %s (%s) and extension %s (%s)" %
* (v, master, len(masterShape), f, len(extShape)))
*/
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5463, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_14);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_14);
__pyx_t_14 = 0;
- __pyx_t_14 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5463, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_14, 0, 0, 0);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5463; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5463, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5462
* # identical (except for that of the unlimited dimension, which of
@@ -63893,14 +63199,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* raise IOError("variable %s : shape mismatch between "
* "master %s (%s) and extension %s (%s)" %
*/
- __pyx_t_14 = __Pyx_PyObject_GetSlice(__pyx_v_masterShape, 1, 0, NULL, NULL, &__pyx_slice__116, 1, 0, 1); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_GetSlice(__pyx_v_masterShape, 1, 0, NULL, NULL, &__pyx_slice__109, 1, 0, 1); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5466, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
- __pyx_t_6 = __Pyx_PyObject_GetSlice(__pyx_v_extShape, 1, 0, NULL, NULL, &__pyx_slice__117, 1, 0, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetSlice(__pyx_v_extShape, 1, 0, NULL, NULL, &__pyx_slice__110, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5466, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_7 = PyObject_RichCompare(__pyx_t_14, __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_RichCompare(__pyx_t_14, __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5466, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5466, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (__pyx_t_2) {
@@ -63911,7 +63217,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Check that the data types are identical.
*/
- __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5469; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5469, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_v_v);
__Pyx_GIVEREF(__pyx_v_v);
@@ -63936,7 +63242,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* (v, master, masterShape, f, extShape))
*
*/
- __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_variable_s_shape_mismatch_betwee, __pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5468; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_variable_s_shape_mismatch_betwee, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5468, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -63947,17 +63253,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* "master %s (%s) and extension %s (%s)" %
* (v, master, masterShape, f, extShape))
*/
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5467; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5467, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6);
__pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5467; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5467, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5467; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5467, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5466
* "master %s (%s) and extension %s (%s)" %
@@ -63975,8 +63281,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* raise IOError("variable %s : data type mismatch between "
* "master %s (%s) and extension %s (%s)" %
*/
- __pyx_t_6 = PyObject_RichCompare(__pyx_v_masterType, __pyx_v_extType, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5472; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5472; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_RichCompare(__pyx_v_masterType, __pyx_v_extType, Py_NE); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5472, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5472, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_2) {
@@ -63987,7 +63293,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Everythig ok.
*/
- __pyx_t_6 = PyTuple_New(5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5475; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5475, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_v);
__Pyx_GIVEREF(__pyx_v_v);
@@ -64012,7 +63318,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* (v, master, masterType, f, extType))
*
*/
- __pyx_t_7 = __Pyx_PyString_Format(__pyx_kp_s_variable_s_data_type_mismatch_be, __pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5474; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyString_Format(__pyx_kp_s_variable_s_data_type_mismatch_be, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5474, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -64023,17 +63329,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* "master %s (%s) and extension %s (%s)" %
* (v, master, masterType, f, extType))
*/
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5473; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7);
__pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5473; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_IOError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5473; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5473, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5472
*
@@ -64051,7 +63357,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* cdfRecVar[v].append(vInst)
* else:
*/
- __pyx_t_7 = PyObject_GetItem(__pyx_v_part->variables, __pyx_v_v); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5478; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = PyObject_GetItem(__pyx_v_part->variables, __pyx_v_v); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5478, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_XDECREF_SET(__pyx_v_vInst, __pyx_t_7);
__pyx_t_7 = 0;
@@ -64063,9 +63369,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* else:
* # No making sure of anything -- assume this is ok..
*/
- __pyx_t_7 = __Pyx_PyDict_GetItem(__pyx_v_cdfRecVar, __pyx_v_v); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5479; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = __Pyx_PyDict_GetItem(__pyx_v_cdfRecVar, __pyx_v_v); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5479, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_7, __pyx_v_vInst); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5479; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_7, __pyx_v_vInst); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5479, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5442
@@ -64086,7 +63392,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
*/
/*else*/ {
- __pyx_t_7 = PyObject_GetItem(__pyx_v_part->variables, __pyx_v_v); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5482; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = PyObject_GetItem(__pyx_v_part->variables, __pyx_v_v); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5482, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_XDECREF_SET(__pyx_v_vInst, __pyx_t_7);
__pyx_t_7 = 0;
@@ -64098,9 +63404,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* cdf.append(part)
*/
- __pyx_t_7 = __Pyx_PyDict_GetItem(__pyx_v_cdfRecVar, __pyx_v_v); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5483; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = __Pyx_PyDict_GetItem(__pyx_v_cdfRecVar, __pyx_v_v); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5483, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_7, __pyx_v_vInst); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5483; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_7, __pyx_v_vInst); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5483, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__pyx_L32:;
@@ -64122,7 +63428,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* cdfVLen.append(len(part.dimensions[aggDimName]))
*
*/
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_cdf, ((PyObject *)__pyx_v_part)); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5485; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_cdf, ((PyObject *)__pyx_v_part)); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5485, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5486
*
@@ -64131,14 +63437,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* # Attach attributes to the MFDataset instance.
*/
- if (unlikely(!__pyx_v_aggDimName)) { __Pyx_RaiseUnboundLocalError("aggDimName"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_4 = PyObject_GetItem(__pyx_v_part->dimensions, __pyx_v_aggDimName); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5486; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ if (unlikely(!__pyx_v_aggDimName)) { __Pyx_RaiseUnboundLocalError("aggDimName"); __PYX_ERR(0, 5486, __pyx_L1_error) }
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_part->dimensions, __pyx_v_aggDimName); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5486, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_12 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_12 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(0, 5486, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyInt_FromSsize_t(__pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5486, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_cdfVLen, __pyx_t_4); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5486; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_cdfVLen, __pyx_t_4); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5486, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "netCDF4/_netCDF4.pyx":5438
@@ -64158,7 +63464,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._cdfVLen = cdfVLen # list of unlimited lengths
* self._cdfTLen = sum(cdfVLen) # total length
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_files_2, __pyx_v_files) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5490; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_files_2, __pyx_v_files) < 0) __PYX_ERR(0, 5490, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5491
* # A local __setattr__() method is required for them.
@@ -64167,7 +63473,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._cdfTLen = sum(cdfVLen) # total length
* self._cdfRecVar = cdfRecVar # dictionary of Variable instances for all
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_cdfVLen, __pyx_v_cdfVLen) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5491; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_cdfVLen, __pyx_v_cdfVLen) < 0) __PYX_ERR(0, 5491, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5492
* self._files = files # list of cdf file names in the set
@@ -64176,15 +63482,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._cdfRecVar = cdfRecVar # dictionary of Variable instances for all
* # the aggregation variables
*/
- __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5492; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_cdfVLen);
__Pyx_GIVEREF(__pyx_v_cdfVLen);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_cdfVLen);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5492; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_sum, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_cdfTLen, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5492; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_cdfTLen, __pyx_t_4) < 0) __PYX_ERR(0, 5492, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "netCDF4/_netCDF4.pyx":5493
@@ -64194,7 +63500,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* # the aggregation variables
* self._dims = cdfm.dimensions
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_cdfRecVar, __pyx_v_cdfRecVar) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5493; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_cdfRecVar, __pyx_v_cdfRecVar) < 0) __PYX_ERR(0, 5493, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5495
* self._cdfRecVar = cdfRecVar # dictionary of Variable instances for all
@@ -64205,7 +63511,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*/
__pyx_t_4 = __pyx_v_cdfm->dimensions;
__Pyx_INCREF(__pyx_t_4);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dims, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5495; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dims, __pyx_t_4) < 0) __PYX_ERR(0, 5495, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "netCDF4/_netCDF4.pyx":5496
@@ -64217,7 +63523,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*/
__pyx_t_4 = __pyx_v_cdfm->groups;
__Pyx_INCREF(__pyx_t_4);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_grps, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5496; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_grps, __pyx_t_4) < 0) __PYX_ERR(0, 5496, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "netCDF4/_netCDF4.pyx":5497
@@ -64227,9 +63533,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* if dimname == aggDimName:
* self._dims[dimname] = _Dimension(dimname, dim, self._cdfVLen, self._cdfTLen)
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dims); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dims); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_items); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_items); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = NULL;
@@ -64243,10 +63549,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_5) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5497, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -64254,9 +63560,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__pyx_t_7 = __pyx_t_4; __Pyx_INCREF(__pyx_t_7); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_10 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5497, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
for (;;) {
@@ -64264,17 +63570,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5497, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_4); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5497, __pyx_L1_error)
#else
- __pyx_t_4 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
@@ -64284,7 +63590,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5497, __pyx_L1_error)
}
break;
}
@@ -64300,7 +63606,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5497, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -64313,15 +63619,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
#else
- __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_14 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_14)->tp_iternext;
@@ -64329,7 +63635,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_GOTREF(__pyx_t_5);
index = 1; __pyx_t_6 = __pyx_t_11(__pyx_t_14); if (unlikely(!__pyx_t_6)) goto __pyx_L42_unpacking_failed;
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_14), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_14), 2) < 0) __PYX_ERR(0, 5497, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
goto __pyx_L43_unpacking_done;
@@ -64337,7 +63643,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5497; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5497, __pyx_L1_error)
__pyx_L43_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_5);
@@ -64352,9 +63658,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._dims[dimname] = _Dimension(dimname, dim, self._cdfVLen, self._cdfTLen)
* self._vars = cdfm.variables
*/
- if (unlikely(!__pyx_v_aggDimName)) { __Pyx_RaiseUnboundLocalError("aggDimName"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5498; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
- __pyx_t_4 = PyObject_RichCompare(__pyx_v_dimname, __pyx_v_aggDimName, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5498; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5498; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(!__pyx_v_aggDimName)) { __Pyx_RaiseUnboundLocalError("aggDimName"); __PYX_ERR(0, 5498, __pyx_L1_error) }
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_dimname, __pyx_v_aggDimName, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5498, __pyx_L1_error)
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5498, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_2) {
@@ -64365,11 +63671,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._vars = cdfm.variables
* for varname,var in self._vars.items():
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_Dimension); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_Dimension); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdfVLen); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdfVLen); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
- __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdfTLen); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdfTLen); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__pyx_t_3 = NULL;
__pyx_t_12 = 0;
@@ -64383,7 +63689,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__pyx_t_12 = 1;
}
}
- __pyx_t_15 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
if (__pyx_t_3) {
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_3); __pyx_t_3 = NULL;
@@ -64400,13 +63706,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_12, __pyx_t_14);
__pyx_t_5 = 0;
__pyx_t_14 = 0;
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_15, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dims); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dims); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- if (unlikely(PyObject_SetItem(__pyx_t_6, __pyx_v_dimname, __pyx_t_4) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5499; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_6, __pyx_v_dimname, __pyx_t_4) < 0)) __PYX_ERR(0, 5499, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -64438,7 +63744,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*/
__pyx_t_7 = __pyx_v_cdfm->variables;
__Pyx_INCREF(__pyx_t_7);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_vars, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5500; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_vars, __pyx_t_7) < 0) __PYX_ERR(0, 5500, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5501
@@ -64448,9 +63754,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* if varname in self._cdfRecVar.keys():
* self._vars[varname] = _Variable(self, varname, var, aggDimName)
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vars); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vars); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_items); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_items); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
@@ -64464,10 +63770,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_4) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5501, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -64475,9 +63781,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__pyx_t_6 = __pyx_t_7; __Pyx_INCREF(__pyx_t_6); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_10 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5501, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -64485,17 +63791,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5501, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_9); __Pyx_INCREF(__pyx_t_7); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5501, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -64505,7 +63811,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5501, __pyx_L1_error)
}
break;
}
@@ -64521,7 +63827,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5501, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -64534,15 +63840,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_15);
#else
- __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_15 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
#endif
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_14 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_14)->tp_iternext;
@@ -64550,7 +63856,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_GOTREF(__pyx_t_4);
index = 1; __pyx_t_15 = __pyx_t_11(__pyx_t_14); if (unlikely(!__pyx_t_15)) goto __pyx_L47_unpacking_failed;
__Pyx_GOTREF(__pyx_t_15);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_14), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_14), 2) < 0) __PYX_ERR(0, 5501, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
goto __pyx_L48_unpacking_done;
@@ -64558,7 +63864,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5501; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5501, __pyx_L1_error)
__pyx_L48_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_varname, __pyx_t_4);
@@ -64573,9 +63879,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._vars[varname] = _Variable(self, varname, var, aggDimName)
* self._file_format = []
*/
- __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdfRecVar); if (unlikely(!__pyx_t_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdfRecVar); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 5502, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_15);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_keys); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_15, __pyx_n_s_keys); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5502, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
__pyx_t_15 = NULL;
@@ -64589,14 +63895,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_15) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_15); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5502, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5502, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_varname, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5502; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_v_varname, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5502, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
@@ -64608,9 +63914,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._file_format = []
* self._data_model = []
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_Variable); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5503; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_Variable); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5503, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- if (unlikely(!__pyx_v_aggDimName)) { __Pyx_RaiseUnboundLocalError("aggDimName"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5503; __pyx_clineno = __LINE__; goto __pyx_L1_error;} }
+ if (unlikely(!__pyx_v_aggDimName)) { __Pyx_RaiseUnboundLocalError("aggDimName"); __PYX_ERR(0, 5503, __pyx_L1_error) }
__pyx_t_15 = NULL;
__pyx_t_12 = 0;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
@@ -64623,7 +63929,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__pyx_t_12 = 1;
}
}
- __pyx_t_14 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5503; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyTuple_New(4+__pyx_t_12); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5503, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
if (__pyx_t_15) {
__Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_15); __pyx_t_15 = NULL;
@@ -64640,13 +63946,13 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_v_aggDimName);
__Pyx_GIVEREF(__pyx_v_aggDimName);
PyTuple_SET_ITEM(__pyx_t_14, 3+__pyx_t_12, __pyx_v_aggDimName);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_14, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5503; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_14, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5503, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vars); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5503; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vars); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5503, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- if (unlikely(PyObject_SetItem(__pyx_t_4, __pyx_v_varname, __pyx_t_7) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5503; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_4, __pyx_v_varname, __pyx_t_7) < 0)) __PYX_ERR(0, 5503, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -64676,9 +63982,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._data_model = []
* self._disk_format = []
*/
- __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5504; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5504, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_file_format_2, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5504; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_file_format_2, __pyx_t_6) < 0) __PYX_ERR(0, 5504, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "netCDF4/_netCDF4.pyx":5505
@@ -64688,9 +63994,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._disk_format = []
* for dset in self._cdf:
*/
- __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5505; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5505, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_data_model_2, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5505; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_data_model_2, __pyx_t_6) < 0) __PYX_ERR(0, 5505, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "netCDF4/_netCDF4.pyx":5506
@@ -64700,9 +64006,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* for dset in self._cdf:
* if dset.file_format == 'NETCDF4' or dset.data_model == 'NETCDF4':
*/
- __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5506; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5506, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_disk_format_2, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5506; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_disk_format, __pyx_t_6) < 0) __PYX_ERR(0, 5506, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "netCDF4/_netCDF4.pyx":5507
@@ -64712,15 +64018,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* if dset.file_format == 'NETCDF4' or dset.data_model == 'NETCDF4':
* raise ValueError('MFNetCDF4 only works with NETCDF3_* and NETCDF4_CLASSIC formatted files, not NETCDF4')
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdf); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdf); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (likely(PyList_CheckExact(__pyx_t_6)) || PyTuple_CheckExact(__pyx_t_6)) {
__pyx_t_7 = __pyx_t_6; __Pyx_INCREF(__pyx_t_7); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
} else {
- __pyx_t_9 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_10 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5507, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
for (;;) {
@@ -64728,17 +64034,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_6 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_6); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_6); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5507, __pyx_L1_error)
#else
- __pyx_t_6 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
} else {
if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_6); __pyx_t_9++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_9); __Pyx_INCREF(__pyx_t_6); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(0, 5507, __pyx_L1_error)
#else
- __pyx_t_6 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(__pyx_t_7, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
}
@@ -64748,7 +64054,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5507; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5507, __pyx_L1_error)
}
break;
}
@@ -64764,18 +64070,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* raise ValueError('MFNetCDF4 only works with NETCDF3_* and NETCDF4_CLASSIC formatted files, not NETCDF4')
* self._file_format.append(dset.file_format)
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_file_format); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5508; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_file_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5508, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5508; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5508, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L53_bool_binop_done;
}
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_data_model); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5508; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_data_model); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5508, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5508; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = (__Pyx_PyString_Equals(__pyx_t_6, __pyx_n_s_NETCDF4, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5508, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L53_bool_binop_done:;
@@ -64788,11 +64094,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._file_format.append(dset.file_format)
* self._data_model.append(dset.data_model)
*/
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__118, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5509; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__111, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5509, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5509; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5509, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5508
* self._disk_format = []
@@ -64810,11 +64116,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._data_model.append(dset.data_model)
* self._disk_format.append(dset.disk_format)
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_file_format_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5510; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_file_format_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_file_format); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5510; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_file_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_t_4); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5510; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_t_4); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5510, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -64825,11 +64131,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._disk_format.append(dset.disk_format)
* self._path = '/'
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_data_model_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5511; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_data_model_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_data_model); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5511; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_data_model); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_6); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5511; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_4, __pyx_t_6); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5511, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -64840,11 +64146,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
* self._path = '/'
*
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_disk_format_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5512; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_disk_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_disk_format); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5512; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_disk_format_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_t_4); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5512; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyObject_Append(__pyx_t_6, __pyx_t_4); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5512, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -64865,7 +64171,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset___init__(CYTHON_UNUSED P
*
* def __setattr__(self, name, value):
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_path_2, __pyx_kp_s__16) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5513; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_path_2, __pyx_kp_s__16) < 0) __PYX_ERR(0, 5513, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5342
* """
@@ -64942,9 +64248,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_3__setattr__(PyObject *_
PyObject *__pyx_v_self = 0;
PyObject *__pyx_v_name = 0;
PyObject *__pyx_v_value = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__setattr__ (wrapper)", 0);
@@ -64969,16 +64272,16 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_3__setattr__(PyObject *_
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__setattr__", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5515; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__setattr__", 1, 3, 3, 1); __PYX_ERR(0, 5515, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__setattr__", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5515; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__setattr__", 1, 3, 3, 2); __PYX_ERR(0, 5515, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__setattr__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5515; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__setattr__") < 0)) __PYX_ERR(0, 5515, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 3) {
goto __pyx_L5_argtuple_error;
@@ -64993,7 +64296,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_3__setattr__(PyObject *_
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__setattr__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5515; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__setattr__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5515, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.MFDataset.__setattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -65010,9 +64313,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_2__setattr__(CYTHON_UNUS
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__setattr__", 0);
/* "netCDF4/_netCDF4.pyx":5517
@@ -65022,9 +64322,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_2__setattr__(CYTHON_UNUS
*
* def __getattribute__(self, name):
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5517; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5517, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_name, __pyx_v_value) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5517; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_name, __pyx_v_value) < 0)) __PYX_ERR(0, 5517, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5515
@@ -65062,9 +64362,6 @@ static PyMethodDef __pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_5__getattribute__ =
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_5__getattribute__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_self = 0;
PyObject *__pyx_v_name = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getattribute__ (wrapper)", 0);
@@ -65088,11 +64385,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_5__getattribute__(PyObje
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__getattribute__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5519; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__getattribute__", 1, 2, 2, 1); __PYX_ERR(0, 5519, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getattribute__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5519; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getattribute__") < 0)) __PYX_ERR(0, 5519, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -65105,7 +64402,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9MFDataset_5__getattribute__(PyObje
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__getattribute__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5519; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__getattribute__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5519, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.MFDataset.__getattribute__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -65128,9 +64425,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
PyObject *__pyx_t_5 = NULL;
Py_ssize_t __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getattribute__", 0);
/* "netCDF4/_netCDF4.pyx":5520
@@ -65142,43 +64436,43 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
*/
__Pyx_INCREF(__pyx_v_name);
__pyx_t_1 = __pyx_v_name;
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_variables, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_variables, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5520, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_dimensions, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_dimensions, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5520, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_file_format, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_file_format, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5520, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_groups, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_groups, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5520, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_data_model, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_data_model, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5520, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_disk_format, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_disk_format_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5520, __pyx_L1_error)
if (!__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_path, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5520; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_n_s_path, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5520, __pyx_L1_error)
__pyx_t_2 = __pyx_t_3;
__pyx_L4_bool_binop_done:;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -65192,10 +64486,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
* if name == 'variables': return self._vars
* if name == 'file_format': return self._file_format
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_dimensions, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5522; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_dimensions, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5522, __pyx_L1_error)
if (__pyx_t_3) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dims); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5522; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dims); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5522, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -65209,10 +64503,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
* if name == 'file_format': return self._file_format
* if name == 'data_model': return self._data_model
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_variables, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_variables, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5523, __pyx_L1_error)
if (__pyx_t_3) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vars); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5523; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_vars); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5523, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -65226,10 +64520,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
* if name == 'data_model': return self._data_model
* if name == 'disk_format': return self._disk_format
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_file_format, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5524; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_file_format, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5524, __pyx_L1_error)
if (__pyx_t_3) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_file_format_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5524; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_file_format_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5524, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -65243,10 +64537,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
* if name == 'disk_format': return self._disk_format
* if name == 'path': return self._path
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_data_model, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_data_model, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5525, __pyx_L1_error)
if (__pyx_t_3) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_data_model_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5525; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_data_model_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5525, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -65260,10 +64554,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
* if name == 'path': return self._path
* if name == 'groups': return self._grps
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_disk_format, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5526; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_disk_format_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5526, __pyx_L1_error)
if (__pyx_t_3) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_disk_format_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5526; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_disk_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -65277,10 +64571,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
* if name == 'groups': return self._grps
* else:
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_path, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_path, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5527, __pyx_L1_error)
if (__pyx_t_3) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_path_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5527; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_path_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5527, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -65294,10 +64588,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
* else:
* return Dataset.__getattribute__(self, name)
*/
- __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_groups, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5528; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_groups, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 5528, __pyx_L1_error)
if (__pyx_t_3) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_grps); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5528; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_grps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -65323,7 +64617,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset), __pyx_n_s_getattribute); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5530; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset), __pyx_n_s_getattribute); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5530, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
__pyx_t_6 = 0;
@@ -65337,7 +64631,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
__pyx_t_6 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5530; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5530, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
@@ -65348,7 +64642,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_4__getattribute__(CYTHON
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_name);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5530; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5530, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -65411,9 +64705,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_6ncattrs(CYTHON_UNUSED P
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("ncattrs", 0);
/* "netCDF4/_netCDF4.pyx":5538
@@ -65424,15 +64715,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_6ncattrs(CYTHON_UNUSED P
* def close(self):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdf); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5538; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdf); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5538, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5538; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5538, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5538; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5538, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5538; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_keys); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5538, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -65446,10 +64737,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_6ncattrs(CYTHON_UNUSED P
}
}
if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5538; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5538, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5538; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5538, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -65511,9 +64802,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_8close(CYTHON_UNUSED PyO
PyObject *(*__pyx_t_4)(PyObject *);
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("close", 0);
/* "netCDF4/_netCDF4.pyx":5546
@@ -65523,15 +64811,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_8close(CYTHON_UNUSED PyO
* dset.close()
*
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdf); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_cdf); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5546, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
__pyx_t_4 = NULL;
} else {
- __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5546, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5546, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -65539,17 +64827,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_8close(CYTHON_UNUSED PyO
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 5546, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5546, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 5546, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5546, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -65559,7 +64847,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_8close(CYTHON_UNUSED PyO
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5546; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5546, __pyx_L1_error)
}
break;
}
@@ -65575,7 +64863,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_8close(CYTHON_UNUSED PyO
*
* def __repr__(self):
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_close); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5547; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_close); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5547, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -65588,10 +64876,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_8close(CYTHON_UNUSED PyO
}
}
if (__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5547; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5547, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5547; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5547, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
@@ -65673,9 +64961,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
PyObject *(*__pyx_t_6)(PyObject *);
int __pyx_t_7;
int __pyx_t_8;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
/* "netCDF4/_netCDF4.pyx":5550
@@ -65685,9 +64970,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* dimnames = tuple([str(dimname) for dimname in self.dimensions.keys()])
* varnames = tuple([str(varname) for varname in self.variables.keys()])
*/
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_r_3, ((PyObject *)Py_TYPE(__pyx_v_self))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5550; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_r_3, ((PyObject *)Py_TYPE(__pyx_v_self))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5550, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5550; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5550, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_1);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
@@ -65702,11 +64987,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* varnames = tuple([str(varname) for varname in self.variables.keys()])
* grpnames = ()
*/
- __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -65720,10 +65005,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5551, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -65731,9 +65016,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
__pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5551, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -65741,17 +65026,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5551, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5551, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -65761,7 +65046,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5551, __pyx_L1_error)
}
break;
}
@@ -65769,19 +65054,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
}
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_dimname);
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_3))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5551; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5551, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_dimnames = ((PyObject*)__pyx_t_4);
@@ -65794,11 +65079,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* grpnames = ()
* if self.path == '/':
*/
- __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_variables); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -65812,10 +65097,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
}
}
if (__pyx_t_3) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5552, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -65823,9 +65108,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
__pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5552, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -65833,17 +65118,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5552, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_5); __Pyx_INCREF(__pyx_t_2); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5552, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -65853,7 +65138,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5552, __pyx_L1_error)
}
break;
}
@@ -65861,19 +65146,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
}
__Pyx_XDECREF_SET(__pyx_v_varname, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_varname);
__Pyx_GIVEREF(__pyx_v_varname);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_varname);
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_3))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyList_AsTuple(((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5552; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_AsTuple(((PyObject*)__pyx_t_4)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5552, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_varnames = ((PyObject*)__pyx_t_1);
@@ -65896,9 +65181,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* ncdump.append('root group (%s data model, file format %s):\n' %
* (self.data_model[0], self.disk_format[0]))
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_path); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5554; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5554, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_kp_s__16, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5554; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = (__Pyx_PyString_Equals(__pyx_t_1, __pyx_kp_s__16, Py_EQ)); if (unlikely(__pyx_t_7 < 0)) __PYX_ERR(0, 5554, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_7) {
@@ -65909,17 +65194,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* else:
* ncdump.append('group %s:\n' % self.path)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5556; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_data_model); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5556, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5556; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5556, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_disk_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5556; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_disk_format_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5556, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5556; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5556, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5556; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5556, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4);
@@ -65935,10 +65220,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* (self.data_model[0], self.disk_format[0]))
* else:
*/
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_root_group_s_data_model_file_for, __pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5555; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_root_group_s_data_model_file_for, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5555, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_3); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5555; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_3); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5555, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "netCDF4/_netCDF4.pyx":5554
@@ -65959,12 +65244,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* self.ncattrs()]
*/
/*else*/ {
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_path); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5558; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5558, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_group_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5558; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_group_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5558, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_1); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5558; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_1); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5558, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__pyx_L7:;
@@ -65976,7 +65261,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* self.ncattrs()]
* ncdump = ncdump + attrs
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5559; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5559, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
/* "netCDF4/_netCDF4.pyx":5560
@@ -65986,7 +65271,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* ncdump = ncdump + attrs
* ncdump.append(' dimensions = %s\n' % str(dimnames))
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_2 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -65999,10 +65284,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
}
}
if (__pyx_t_2) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5560, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5560, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -66010,9 +65295,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
__pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
__pyx_t_6 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5560, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
for (;;) {
@@ -66020,17 +65305,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5560, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5560, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5560, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
}
@@ -66040,7 +65325,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5560; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5560, __pyx_L1_error)
}
break;
}
@@ -66056,12 +65341,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* self.ncattrs()]
* ncdump = ncdump + attrs
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5559; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5559, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_v_name); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5559; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_t_3, __pyx_v_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5559, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5559; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5559, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
@@ -66069,10 +65354,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5559; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5559, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5559; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 5559, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
@@ -66086,7 +65371,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* ncdump.append(' dimensions = %s\n' % str(dimnames))
* ncdump.append(' variables = %s\n' % str(varnames))
*/
- __pyx_t_1 = PyNumber_Add(__pyx_v_ncdump, __pyx_v_attrs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5561; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_v_ncdump, __pyx_v_attrs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5561, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF_SET(__pyx_v_ncdump, ((PyObject*)__pyx_t_1));
__pyx_t_1 = 0;
@@ -66098,18 +65383,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* ncdump.append(' variables = %s\n' % str(varnames))
* ncdump.append(' groups = %s\n' % str(grpnames))
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5562; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5562, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_dimnames);
__Pyx_GIVEREF(__pyx_v_dimnames);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_dimnames);
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5562; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5562, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_dimensions_s, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5562; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_dimensions_s, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5562, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_1); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5562; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_1); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5562, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5563
@@ -66119,18 +65404,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* ncdump.append(' groups = %s\n' % str(grpnames))
* return ''.join(ncdump)
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5563; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5563, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_varnames);
__Pyx_GIVEREF(__pyx_v_varnames);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_varnames);
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5563; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5563, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_variables_s, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5563; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_variables_s, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5563, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_1); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5563; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_1); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5563, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5564
@@ -66140,18 +65425,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* return ''.join(ncdump)
*
*/
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5564; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5564, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_grpnames);
__Pyx_GIVEREF(__pyx_v_grpnames);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_grpnames);
- __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5564; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5564, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_groups_s_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5564; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_groups_s_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5564, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_1); if (unlikely(__pyx_t_8 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5564; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_ncdump, __pyx_t_1); if (unlikely(__pyx_t_8 == -1)) __PYX_ERR(0, 5564, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5565
@@ -66162,7 +65447,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9MFDataset_10__repr__(CYTHON_UNUSED
* class _Dimension(object):
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_v_ncdump); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5565; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_v_ncdump); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5565, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -66215,9 +65500,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_10_Dimension_1__init__(PyObject *__
CYTHON_UNUSED PyObject *__pyx_v_dim = 0;
PyObject *__pyx_v_dimlens = 0;
PyObject *__pyx_v_dimtotlen = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -66244,26 +65526,26 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_10_Dimension_1__init__(PyObject *__
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dimname)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 1); __PYX_ERR(0, 5568, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dim)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 2); __PYX_ERR(0, 5568, __pyx_L3_error)
}
case 3:
if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dimlens)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 3); __PYX_ERR(0, 5568, __pyx_L3_error)
}
case 4:
if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dimtotlen)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 4); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 4); __PYX_ERR(0, 5568, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 5568, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
goto __pyx_L5_argtuple_error;
@@ -66282,7 +65564,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_10_Dimension_1__init__(PyObject *__
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5568, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4._Dimension.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -66298,9 +65580,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_10_Dimension_1__init__(PyObject *__
static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_dimname, CYTHON_UNUSED PyObject *__pyx_v_dim, PyObject *__pyx_v_dimlens, PyObject *__pyx_v_dimtotlen) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
/* "netCDF4/_netCDF4.pyx":5569
@@ -66310,7 +65589,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension___init__(CYTHON_UNUSED
* self.dimtotlen = dimtotlen
* self._name = dimname
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dimlens, __pyx_v_dimlens) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5569; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dimlens, __pyx_v_dimlens) < 0) __PYX_ERR(0, 5569, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5570
* def __init__(self, dimname, dim, dimlens, dimtotlen):
@@ -66319,7 +65598,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension___init__(CYTHON_UNUSED
* self._name = dimname
* def __len__(self):
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dimtotlen, __pyx_v_dimtotlen) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5570; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dimtotlen, __pyx_v_dimtotlen) < 0) __PYX_ERR(0, 5570, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5571
* self.dimlens = dimlens
@@ -66328,7 +65607,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension___init__(CYTHON_UNUSED
* def __len__(self):
* return self.dimtotlen
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_name_2, __pyx_v_dimname) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5571; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_name_2, __pyx_v_dimname) < 0) __PYX_ERR(0, 5571, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5568
*
@@ -66376,9 +65655,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_2__len__(CYTHON_UNUSED
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__len__", 0);
/* "netCDF4/_netCDF4.pyx":5573
@@ -66389,7 +65665,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_2__len__(CYTHON_UNUSED
* return True
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dimtotlen); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5573; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dimtotlen); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5573, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -66499,9 +65775,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_6__repr__(CYTHON_UNUSE
int __pyx_t_4;
Py_ssize_t __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
/* "netCDF4/_netCDF4.pyx":5577
@@ -66511,7 +65784,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_6__repr__(CYTHON_UNUSE
* return repr(type(self))+" (unlimited): name = '%s', size = %s\n" % (self._name,len(self))
* else:
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5577; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_2))) {
@@ -66524,14 +65797,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_6__repr__(CYTHON_UNUSE
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5577; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5577, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5577; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5577, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5577; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 5577, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_4) {
@@ -66543,14 +65816,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_6__repr__(CYTHON_UNUSE
* return repr(type(self))+": name = '%s', size = %s\n" % (self._name,len(self))
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = PyObject_Repr(((PyObject *)Py_TYPE(__pyx_v_self))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5578; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_Repr(((PyObject *)Py_TYPE(__pyx_v_self))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5578, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5578; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5578, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_5 = PyObject_Length(__pyx_v_self); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5578; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5578; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_Length(__pyx_v_self); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(0, 5578, __pyx_L1_error)
+ __pyx_t_3 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5578, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5578; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5578, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2);
@@ -66558,10 +65831,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_6__repr__(CYTHON_UNUSE
PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_3);
__pyx_t_2 = 0;
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_unlimited_name_s_size_s, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5578; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_unlimited_name_s_size_s, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5578, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5578; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5578, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -66587,14 +65860,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_6__repr__(CYTHON_UNUSE
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_6 = PyObject_Repr(((PyObject *)Py_TYPE(__pyx_v_self))); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5580; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyObject_Repr(((PyObject *)Py_TYPE(__pyx_v_self))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5580, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5580; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5580, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = PyObject_Length(__pyx_v_self); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5580; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5580; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_Length(__pyx_v_self); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(0, 5580, __pyx_L1_error)
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5580, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5580; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5580, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
@@ -66602,10 +65875,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_10_Dimension_6__repr__(CYTHON_UNUSE
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1);
__pyx_t_3 = 0;
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_name_s_size_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5580; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_name_s_size_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5580, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Add(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5580; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Add(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5580, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -66653,9 +65926,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_1__init__(PyObject *__py
PyObject *__pyx_v_varname = 0;
PyObject *__pyx_v_var = 0;
PyObject *__pyx_v_recdimname = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -66682,26 +65952,26 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_1__init__(PyObject *__py
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_dset)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 1); __PYX_ERR(0, 5583, __pyx_L3_error)
}
case 2:
if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_varname)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 2); __PYX_ERR(0, 5583, __pyx_L3_error)
}
case 3:
if (likely((values[3] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_var)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 3); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 3); __PYX_ERR(0, 5583, __pyx_L3_error)
}
case 4:
if (likely((values[4] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_recdimname)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 4); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, 4); __PYX_ERR(0, 5583, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 5583, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 5) {
goto __pyx_L5_argtuple_error;
@@ -66720,7 +65990,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_1__init__(PyObject *__py
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 1, 5, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5583, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4._Variable.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -66746,9 +66016,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *(*__pyx_t_8)(PyObject *);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
/* "netCDF4/_netCDF4.pyx":5584
@@ -66758,9 +66025,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self._dset = dset
* self._grp = dset
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5584; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5584, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dimensions, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5584; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dimensions, __pyx_t_1) < 0) __PYX_ERR(0, 5584, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5585
@@ -66770,7 +66037,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self._grp = dset
* self._mastervar = var
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dset_2, __pyx_v_dset) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5585; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dset_2, __pyx_v_dset) < 0) __PYX_ERR(0, 5585, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5586
* self.dimensions = var.dimensions
@@ -66779,7 +66046,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self._mastervar = var
* self._recVar = dset._cdfRecVar[varname]
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_grp_2, __pyx_v_dset) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5586; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_grp_2, __pyx_v_dset) < 0) __PYX_ERR(0, 5586, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5587
* self._dset = dset
@@ -66788,7 +66055,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self._recVar = dset._cdfRecVar[varname]
* self._recdimname = recdimname
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mastervar, __pyx_v_var) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5587; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_mastervar, __pyx_v_var) < 0) __PYX_ERR(0, 5587, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5588
* self._grp = dset
@@ -66797,12 +66064,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self._recdimname = recdimname
* self._recLen = dset._cdfVLen
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_cdfRecVar); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5588; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_cdfRecVar); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5588, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_GetItem(__pyx_t_1, __pyx_v_varname); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5588; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_t_1, __pyx_v_varname); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5588, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_recVar, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5588; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_recVar, __pyx_t_2) < 0) __PYX_ERR(0, 5588, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5589
@@ -66812,7 +66079,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self._recLen = dset._cdfVLen
* self.dtype = var.dtype
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_recdimname_2, __pyx_v_recdimname) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5589; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_recdimname_2, __pyx_v_recdimname) < 0) __PYX_ERR(0, 5589, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5590
* self._recVar = dset._cdfRecVar[varname]
@@ -66821,9 +66088,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self.dtype = var.dtype
* self._name = var._name
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_cdfVLen); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5590; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dset, __pyx_n_s_cdfVLen); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5590, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_recLen, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5590; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_recLen, __pyx_t_2) < 0) __PYX_ERR(0, 5590, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5591
@@ -66833,9 +66100,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self._name = var._name
* # copy attributes from master.
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5591; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5591, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dtype, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5591; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_dtype, __pyx_t_2) < 0) __PYX_ERR(0, 5591, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5592
@@ -66845,9 +66112,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* # copy attributes from master.
* for name, value in var.__dict__.items():
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5592; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_name_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5592, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_name_2, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5592; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_name_2, __pyx_t_2) < 0) __PYX_ERR(0, 5592, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5594
@@ -66857,9 +66124,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* self.__dict__[name] = value
* def typecode(self):
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_dict); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_var, __pyx_n_s_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -66873,10 +66140,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
}
}
if (__pyx_t_1) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5594, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -66884,9 +66151,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
__pyx_t_3 = __pyx_t_2; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5594, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -66894,17 +66161,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5594, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5594, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -66914,7 +66181,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5594, __pyx_L1_error)
}
break;
}
@@ -66930,7 +66197,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5594, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -66943,15 +66210,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_6);
#else
- __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_7 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5594, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
@@ -66959,7 +66226,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
__Pyx_GOTREF(__pyx_t_1);
index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 5594, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L6_unpacking_done;
@@ -66967,7 +66234,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5594; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5594, __pyx_L1_error)
__pyx_L6_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_1);
@@ -66982,9 +66249,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable___init__(CYTHON_UNUSED P
* def typecode(self):
* return self.dtype
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5595; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5595, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_name, __pyx_v_value) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5595; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_v_name, __pyx_v_value) < 0)) __PYX_ERR(0, 5595, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5594
@@ -67050,9 +66317,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_2typecode(CYTHON_UNUSED
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("typecode", 0);
/* "netCDF4/_netCDF4.pyx":5597
@@ -67063,7 +66327,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_2typecode(CYTHON_UNUSED
* return self._mastervar.__dict__.keys()
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5597; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5597, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -67116,9 +66380,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_4ncattrs(CYTHON_UNUSED P
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("ncattrs", 0);
/* "netCDF4/_netCDF4.pyx":5599
@@ -67129,12 +66390,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_4ncattrs(CYTHON_UNUSED P
* if name == 'shape': return self._shape()
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mastervar); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5599; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mastervar); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_dict); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5599; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_dict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5599; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_keys); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5599, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -67148,10 +66409,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_4ncattrs(CYTHON_UNUSED P
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5599; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5599, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5599; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5599, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -67194,9 +66455,6 @@ static PyMethodDef __pyx_mdef_7netCDF4_8_netCDF4_9_Variable_7__getattr__ = {"__g
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_7__getattr__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_self = 0;
PyObject *__pyx_v_name = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0);
@@ -67220,11 +66478,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_7__getattr__(PyObject *_
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__getattr__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5600; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__getattr__", 1, 2, 2, 1); __PYX_ERR(0, 5600, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getattr__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5600; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getattr__") < 0)) __PYX_ERR(0, 5600, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -67237,7 +66495,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_7__getattr__(PyObject *_
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__getattr__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5600; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__getattr__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5600, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4._Variable.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -67263,9 +66521,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getattr__", 0);
/* "netCDF4/_netCDF4.pyx":5601
@@ -67275,10 +66530,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
* if name == 'ndim': return len(self._shape())
* try:
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_shape, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5601; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_shape, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 5601, __pyx_L1_error)
if (__pyx_t_1) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5601; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5601, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -67291,10 +66546,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
}
}
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5601; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5601, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5601; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5601, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -67310,10 +66565,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
* try:
* return self.__dict__[name]
*/
- __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_ndim, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = (__Pyx_PyString_Equals(__pyx_v_name, __pyx_n_s_ndim, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 5602, __pyx_L1_error)
if (__pyx_t_1) {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5602, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -67326,16 +66581,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
}
}
if (__pyx_t_4) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5602, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5602, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_5 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_Length(__pyx_t_2); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(0, 5602, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5602; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5602, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
@@ -67350,6 +66605,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
* except:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
@@ -67364,9 +66621,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
* raise AttributeError(name)
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5604; __pyx_clineno = __LINE__; goto __pyx_L5_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5604, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_v_name); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5604; __pyx_clineno = __LINE__; goto __pyx_L5_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5604, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_3;
@@ -67382,6 +66639,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
*/
}
__pyx_L5_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -67395,7 +66653,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
*/
/*except:*/ {
__Pyx_AddTraceback("netCDF4._netCDF4._Variable.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5605; __pyx_clineno = __LINE__; goto __pyx_L7_except_error;}
+ if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_4) < 0) __PYX_ERR(0, 5605, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_4);
@@ -67407,17 +66665,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
* def __repr__(self):
* ncdump_var = ['%r\n' % type(self)]
*/
- __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5606; __pyx_clineno = __LINE__; goto __pyx_L7_except_error;}
+ __pyx_t_9 = PyTuple_New(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5606, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_v_name);
- __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5606; __pyx_clineno = __LINE__; goto __pyx_L7_except_error;}
+ __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_AttributeError, __pyx_t_9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5606, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_Raise(__pyx_t_10, 0, 0, 0);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5606; __pyx_clineno = __LINE__; goto __pyx_L7_except_error;}
+ __PYX_ERR(0, 5606, __pyx_L7_except_error)
}
__pyx_L7_except_error:;
@@ -67428,12 +66686,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_6__getattr__(CYTHON_UNUS
* return self.__dict__[name]
* except:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L1_error;
__pyx_L9_try_return:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
@@ -67507,9 +66767,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
Py_ssize_t __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
int __pyx_t_11;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__repr__", 0);
/* "netCDF4/_netCDF4.pyx":5608
@@ -67519,9 +66776,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* dimnames = tuple([str(dimname) for dimname in self.dimensions])
* attrs = [' %s: %s\n' % (name,self.__dict__[name]) for name in\
*/
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_r_3, ((PyObject *)Py_TYPE(__pyx_v_self))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_r_3, ((PyObject *)Py_TYPE(__pyx_v_self))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5608; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5608, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_1);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
@@ -67536,17 +66793,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* attrs = [' %s: %s\n' % (name,self.__dict__[name]) for name in\
* self.ncattrs()]
*/
- __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5609, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -67554,17 +66811,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5609, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5609, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -67574,7 +66831,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5609, __pyx_L1_error)
}
break;
}
@@ -67582,19 +66839,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
}
__Pyx_XDECREF_SET(__pyx_v_dimname, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_dimname);
- __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5609; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5609, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_dimnames = ((PyObject*)__pyx_t_3);
@@ -67607,7 +66864,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* self.ncattrs()]
* ncdump_var.append('%s %s%s\n' %\
*/
- __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "netCDF4/_netCDF4.pyx":5611
@@ -67617,7 +66874,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* ncdump_var.append('%s %s%s\n' %\
* (self.dtype,self._name,dimnames))
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ncattrs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_1 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) {
@@ -67630,10 +66887,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
}
}
if (__pyx_t_1) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5611, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5611, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -67641,9 +66898,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
__pyx_t_6 = __pyx_t_2; __Pyx_INCREF(__pyx_t_6); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_5 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5611, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
@@ -67651,17 +66908,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5611, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_2); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5611, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5611, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -67671,7 +66928,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5611; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5611, __pyx_L1_error)
}
break;
}
@@ -67687,12 +66944,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* self.ncattrs()]
* ncdump_var.append('%s %s%s\n' %\
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = PyObject_GetItem(__pyx_t_2, __pyx_v_name); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5610; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = PyObject_GetItem(__pyx_t_2, __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
@@ -67700,10 +66957,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_s_s, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5610, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_1))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_1))) __PYX_ERR(0, 5610, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -67717,11 +66974,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* ncdump_var = ncdump_var + attrs
* unlimdims = []
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5613, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5613, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5613; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5613, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
@@ -67740,10 +66997,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* (self.dtype,self._name,dimnames))
* ncdump_var = ncdump_var + attrs
*/
- __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s_2, __pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_s_s_s_2, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5612, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_6); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5612; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_6); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 5612, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "netCDF4/_netCDF4.pyx":5614
@@ -67753,7 +67010,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* unlimdims = []
* for dimname in self.dimensions:
*/
- __pyx_t_6 = PyNumber_Add(__pyx_v_ncdump_var, __pyx_v_attrs); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5614; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyNumber_Add(__pyx_v_ncdump_var, __pyx_v_attrs); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5614, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF_SET(__pyx_v_ncdump_var, ((PyObject*)__pyx_t_6));
__pyx_t_6 = 0;
@@ -67765,7 +67022,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* for dimname in self.dimensions:
* dim = _find_dim(self._grp, dimname)
*/
- __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5615; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5615, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_v_unlimdims = ((PyObject*)__pyx_t_6);
__pyx_t_6 = 0;
@@ -67777,15 +67034,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* dim = _find_dim(self._grp, dimname)
* if dim.isunlimited():
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5616; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (likely(PyList_CheckExact(__pyx_t_6)) || PyTuple_CheckExact(__pyx_t_6)) {
__pyx_t_1 = __pyx_t_6; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5616; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5616; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5616, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
for (;;) {
@@ -67793,17 +67050,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_6 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5616; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5616, __pyx_L1_error)
#else
- __pyx_t_6 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5616; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5616; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_6); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5616, __pyx_L1_error)
#else
- __pyx_t_6 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5616; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5616, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
}
@@ -67813,7 +67070,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5616; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5616, __pyx_L1_error)
}
break;
}
@@ -67829,9 +67086,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* if dim.isunlimited():
* unlimdims.append(str(dimname))
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5617; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_find_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5617, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_grp_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5617; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_grp_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5617, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_8 = NULL;
__pyx_t_9 = 0;
@@ -67845,7 +67102,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
__pyx_t_9 = 1;
}
}
- __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5617; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5617, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
@@ -67856,7 +67113,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_v_dimname);
__pyx_t_2 = 0;
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5617; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5617, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -67870,7 +67127,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* unlimdims.append(str(dimname))
* ncdump_var.append('unlimited dimensions = %s\n' % repr(tuple(unlimdims)))
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5618; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dim, __pyx_n_s_isunlimited); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5618, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_10 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) {
@@ -67883,14 +67140,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
}
}
if (__pyx_t_10) {
- __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5618; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5618, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
- __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5618; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5618, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5618; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5618, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_11) {
@@ -67901,15 +67158,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* ncdump_var.append('unlimited dimensions = %s\n' % repr(tuple(unlimdims)))
* ncdump_var.append('current size = %s\n' % repr(self.shape))
*/
- __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5619; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5619, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_dimname);
__Pyx_GIVEREF(__pyx_v_dimname);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_v_dimname);
- __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5619; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)(&PyString_Type)), __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5619, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_unlimdims, __pyx_t_3); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5619; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_unlimdims, __pyx_t_3); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 5619, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "netCDF4/_netCDF4.pyx":5618
@@ -67938,15 +67195,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* ncdump_var.append('current size = %s\n' % repr(self.shape))
* return ''.join(ncdump_var)
*/
- __pyx_t_1 = PyList_AsTuple(__pyx_v_unlimdims); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_AsTuple(__pyx_v_unlimdims); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5620, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = PyObject_Repr(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_Repr(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5620, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_unlimited_dimensions_s_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_unlimited_dimensions_s_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5620, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_1); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_1); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 5620, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5621
@@ -67956,15 +67213,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* return ''.join(ncdump_var)
* def __len__(self):
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5621; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5621, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = PyObject_Repr(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5621; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_Repr(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5621, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_current_size_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5621; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_current_size_s, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5621, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_1); if (unlikely(__pyx_t_7 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5621; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_ncdump_var, __pyx_t_1); if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(0, 5621, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5622
@@ -67975,7 +67232,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_8__repr__(CYTHON_UNUSED
* if not self._shape:
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_v_ncdump_var); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5622; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyString_Join(__pyx_kp_s__2, __pyx_v_ncdump_var); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5622, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
@@ -68042,9 +67299,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_10__len__(CYTHON_UNUSED
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__len__", 0);
/* "netCDF4/_netCDF4.pyx":5624
@@ -68054,9 +67308,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_10__len__(CYTHON_UNUSED
* raise TypeError('len() of unsized object')
* else:
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5624; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5624, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5624; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 5624, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = ((!__pyx_t_2) != 0);
if (__pyx_t_3) {
@@ -68068,11 +67322,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_10__len__(CYTHON_UNUSED
* else:
* return self._shape()[0]
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__119, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__112, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5625, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5625, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5624
* return ''.join(ncdump_var)
@@ -68092,7 +67346,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_10__len__(CYTHON_UNUSED
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5627, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) {
@@ -68105,14 +67359,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_10__len__(CYTHON_UNUSED
}
}
if (__pyx_t_5) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5627, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5627, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5627; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5627, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_4;
@@ -68171,9 +67425,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_12_shape(CYTHON_UNUSED P
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
Py_ssize_t __pyx_t_4;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("_shape", 0);
/* "netCDF4/_netCDF4.pyx":5629
@@ -68183,18 +67434,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_12_shape(CYTHON_UNUSED P
* return (recdimlen,) + self._mastervar.shape[1:]
* def set_auto_maskandscale(self,val):
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dset_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5629; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dset_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5629, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5629; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_dimensions); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5629, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recdimname_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5629; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recdimname_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5629, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_t_1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5629; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5629, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_4 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5629; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_Length(__pyx_t_3); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 5629, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_recdimlen = __pyx_t_4;
@@ -68206,22 +67457,22 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_12_shape(CYTHON_UNUSED P
* for v in self._recVar:
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_recdimlen); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_recdimlen); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mastervar); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_mastervar); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_2, 1, 0, NULL, NULL, &__pyx_slice__120, 1, 0, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_2, 1, 0, NULL, NULL, &__pyx_slice__113, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5630, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -68264,9 +67515,6 @@ static PyMethodDef __pyx_mdef_7netCDF4_8_netCDF4_9_Variable_15set_auto_maskandsc
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_15set_auto_maskandscale(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_self = 0;
PyObject *__pyx_v_val = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("set_auto_maskandscale (wrapper)", 0);
@@ -68290,11 +67538,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_15set_auto_maskandscale(
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_val)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("set_auto_maskandscale", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5631; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("set_auto_maskandscale", 1, 2, 2, 1); __PYX_ERR(0, 5631, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_auto_maskandscale") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5631; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "set_auto_maskandscale") < 0)) __PYX_ERR(0, 5631, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -68307,7 +67555,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_15set_auto_maskandscale(
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("set_auto_maskandscale", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5631; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("set_auto_maskandscale", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5631, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4._Variable.set_auto_maskandscale", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -68331,9 +67579,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_14set_auto_maskandscale(
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("set_auto_maskandscale", 0);
/* "netCDF4/_netCDF4.pyx":5632
@@ -68343,15 +67588,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_14set_auto_maskandscale(
* v.set_auto_maskandscale(val)
* def __getitem__(self, elem):
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
__pyx_t_4 = NULL;
} else {
- __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5632, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -68359,17 +67604,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_14set_auto_maskandscale(
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 5632, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_1); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 5632, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5632, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -68379,7 +67624,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_14set_auto_maskandscale(
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5632, __pyx_L1_error)
}
break;
}
@@ -68395,7 +67640,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_14set_auto_maskandscale(
* def __getitem__(self, elem):
* """Get records from a concatenated set of variables."""
*/
- __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_set_auto_maskandscale); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5633; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_set_auto_maskandscale); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) {
@@ -68408,16 +67653,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_14set_auto_maskandscale(
}
}
if (!__pyx_t_6) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_val); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5633; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_val); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5633; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_val);
__Pyx_GIVEREF(__pyx_v_val);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_val);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5633; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
@@ -68475,9 +67720,6 @@ static PyMethodDef __pyx_mdef_7netCDF4_8_netCDF4_9_Variable_17__getitem__ = {"__
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_17__getitem__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_self = 0;
PyObject *__pyx_v_elem = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
@@ -68501,11 +67743,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_17__getitem__(PyObject *
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_elem)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5634; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, 1); __PYX_ERR(0, 5634, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getitem__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5634; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getitem__") < 0)) __PYX_ERR(0, 5634, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -68518,7 +67760,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_9_Variable_17__getitem__(PyObject *
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5634; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5634, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4._Variable.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -68585,9 +67827,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyObject *__pyx_t_21 = NULL;
int __pyx_t_22;
int __pyx_t_23;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getitem__", 0);
/* "netCDF4/_netCDF4.pyx":5643
@@ -68597,9 +67836,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* datashape = _out_array_shape(count)
* data = ma.empty(datashape, dtype=self.dtype)
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_StartCountStride); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_StartCountStride); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5643, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5643, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
__pyx_t_5 = 0;
@@ -68613,7 +67852,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__pyx_t_5 = 1;
}
}
- __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5643, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -68624,7 +67863,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5643; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5643, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -68638,7 +67877,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
if (unlikely(size != 4)) {
if (size > 4) __Pyx_RaiseTooManyValuesError(4);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5642; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5642, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -68661,7 +67900,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
Py_ssize_t i;
PyObject** temps[4] = {&__pyx_t_2,&__pyx_t_6,&__pyx_t_3,&__pyx_t_4};
for (i=0; i < 4; i++) {
- PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5642; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 5642, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
@@ -68671,7 +67910,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
} else {
Py_ssize_t index = -1;
PyObject** temps[4] = {&__pyx_t_2,&__pyx_t_6,&__pyx_t_3,&__pyx_t_4};
- __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5642; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5642, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
@@ -68680,7 +67919,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5642; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 4) < 0) __PYX_ERR(0, 5642, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L4_unpacking_done;
@@ -68688,7 +67927,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5642; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5642, __pyx_L1_error)
__pyx_L4_unpacking_done:;
}
@@ -68715,7 +67954,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* data = ma.empty(datashape, dtype=self.dtype)
*
*/
- __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_out_array_shape); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_out_array_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) {
@@ -68728,16 +67967,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_count); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_count);
__Pyx_GIVEREF(__pyx_v_count);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_count);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5644, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
@@ -68752,23 +67991,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # Determine which dimensions need to be squeezed
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_empty); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_datashape);
__Pyx_GIVEREF(__pyx_v_datashape);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_datashape);
- __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dtype); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_dtype, __pyx_t_3) < 0) __PYX_ERR(0, 5645, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5645; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -68783,14 +68022,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* for i,n in enumerate(put_ind.shape[:-1]):
* if n == 1 and put_ind[...,i].ravel()[0] == -1:
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5651; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5651, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5651; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PyList_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5651, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __Pyx_INCREF(__pyx_slice__121);
- __Pyx_GIVEREF(__pyx_slice__121);
- PyList_SET_ITEM(__pyx_t_6, 0, __pyx_slice__121);
- __pyx_t_1 = PyNumber_Multiply(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5651; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_INCREF(__pyx_slice__114);
+ __Pyx_GIVEREF(__pyx_slice__114);
+ PyList_SET_ITEM(__pyx_t_6, 0, __pyx_slice__114);
+ __pyx_t_1 = PyNumber_Multiply(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5651, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -68806,18 +68045,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*/
__Pyx_INCREF(__pyx_int_0);
__pyx_t_1 = __pyx_int_0;
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_shape); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5652, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_6, 0, -1L, NULL, NULL, &__pyx_slice__122, 0, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_t_6, 0, -1L, NULL, NULL, &__pyx_slice__115, 0, 1, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5652, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
__pyx_t_6 = __pyx_t_3; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0;
__pyx_t_9 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5652, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_9 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5652, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
for (;;) {
@@ -68825,17 +68064,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5652, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5652, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5652, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5652, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
}
@@ -68845,7 +68084,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5652, __pyx_L1_error)
}
break;
}
@@ -68855,7 +68094,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__pyx_t_3 = 0;
__Pyx_INCREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1);
- __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5652, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1);
__pyx_t_1 = __pyx_t_3;
@@ -68868,16 +68107,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* squeeze[i] = 0
*
*/
- __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_n, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_v_n, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_11) {
} else {
__pyx_t_10 = __pyx_t_11;
goto __pyx_L8_bool_binop_done;
}
- __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(Py_Ellipsis);
__Pyx_GIVEREF(Py_Ellipsis);
@@ -68885,10 +68124,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_INCREF(__pyx_v_i);
__Pyx_GIVEREF(__pyx_v_i);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_i);
- __pyx_t_2 = PyObject_GetItem(__pyx_v_put_ind, __pyx_t_4); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_v_put_ind, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ravel); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_ravel); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -68902,20 +68141,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (__pyx_t_2) {
- __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5653, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_3, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_4, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyInt_EqObjC(__pyx_t_4, __pyx_int_neg_1, -1L, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5653; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5653, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_10 = __pyx_t_11;
__pyx_L8_bool_binop_done:;
@@ -68928,7 +68167,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # Reshape the arrays so we can iterate over them.
*/
- if (unlikely(PyObject_SetItem(__pyx_v_squeeze, __pyx_v_i, __pyx_int_0) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5654; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_squeeze, __pyx_v_i, __pyx_int_0) < 0)) __PYX_ERR(0, 5654, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5653
* squeeze = data.ndim * [slice(None),]
@@ -68957,11 +68196,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* cnt = count.reshape((-1, self.ndim or 1))
* strd = stride.reshape((-1, self.ndim or 1))
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_start, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_start, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5657, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5657, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 5657, __pyx_L1_error)
if (!__pyx_t_10) {
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
@@ -68970,12 +68209,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L10_bool_binop_done;
}
- __pyx_t_4 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5657, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __pyx_t_4;
__pyx_t_4 = 0;
__pyx_L10_bool_binop_done:;
- __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5657, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -68994,17 +68233,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5657, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5657, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5657; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5657, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -69019,11 +68258,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* strd = stride.reshape((-1, self.ndim or 1))
* put_ind = put_ind.reshape((-1, self.ndim or 1))
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_count, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_count, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 5658, __pyx_L1_error)
if (!__pyx_t_10) {
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
@@ -69032,12 +68271,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L12_bool_binop_done;
}
- __pyx_t_4 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_2 = __pyx_t_4;
__pyx_t_4 = 0;
__pyx_L12_bool_binop_done:;
- __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -69056,17 +68295,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5658, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5658; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5658, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
@@ -69081,11 +68320,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* put_ind = put_ind.reshape((-1, self.ndim or 1))
*
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_stride, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_stride, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5659, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5659, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 5659, __pyx_L1_error)
if (!__pyx_t_10) {
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
@@ -69094,12 +68333,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L14_bool_binop_done;
}
- __pyx_t_4 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5659, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __pyx_t_4;
__pyx_t_4 = 0;
__pyx_L14_bool_binop_done:;
- __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5659, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -69118,17 +68357,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5659, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5659, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5659, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -69143,11 +68382,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # Fill output array with data chunks.
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_put_ind, __pyx_n_s_reshape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_ndim); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 5660, __pyx_L1_error)
if (!__pyx_t_10) {
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
@@ -69156,12 +68395,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L16_bool_binop_done;
}
- __pyx_t_4 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyInt_From_long(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_2 = __pyx_t_4;
__pyx_t_4 = 0;
__pyx_L16_bool_binop_done:;
- __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_int_neg_1);
__Pyx_GIVEREF(__pyx_int_neg_1);
@@ -69180,17 +68419,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5660, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
- __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5660; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
@@ -69205,9 +68444,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* for (start,count,stride,ind) in zip(strt, cnt, strd, put_ind):
* # make sure count=-1 becomes count=1
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recLen); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5664; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recLen); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5664, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_5 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5664; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(0, 5664, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_nv = __pyx_t_5;
@@ -69218,7 +68457,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* # make sure count=-1 becomes count=1
* count = [abs(cnt) for cnt in count]
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5665, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = NULL;
__pyx_t_5 = 0;
@@ -69232,7 +68471,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__pyx_t_5 = 1;
}
}
- __pyx_t_4 = PyTuple_New(4+__pyx_t_5); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(4+__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5665, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (__pyx_t_3) {
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
@@ -69249,7 +68488,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_INCREF(__pyx_v_put_ind);
__Pyx_GIVEREF(__pyx_v_put_ind);
PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_5, __pyx_v_put_ind);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5665, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -69257,9 +68496,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__pyx_t_6 = __pyx_t_1; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0;
__pyx_t_9 = NULL;
} else {
- __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5665, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_9 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5665, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -69267,17 +68506,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5665, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5665, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_1); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(0, 5665, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5665, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -69287,7 +68526,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5665, __pyx_L1_error)
}
break;
}
@@ -69303,7 +68542,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
if (unlikely(size != 4)) {
if (size > 4) __Pyx_RaiseTooManyValuesError(4);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5665, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -69326,7 +68565,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
Py_ssize_t i;
PyObject** temps[4] = {&__pyx_t_4,&__pyx_t_3,&__pyx_t_2,&__pyx_t_7};
for (i=0; i < 4; i++) {
- PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(0, 5665, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
@@ -69336,7 +68575,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
} else {
Py_ssize_t index = -1;
PyObject** temps[4] = {&__pyx_t_4,&__pyx_t_3,&__pyx_t_2,&__pyx_t_7};
- __pyx_t_12 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5665, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_12)->tp_iternext;
@@ -69345,7 +68584,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_12), 4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_12), 4) < 0) __PYX_ERR(0, 5665, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
goto __pyx_L21_unpacking_done;
@@ -69353,7 +68592,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5665; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5665, __pyx_L1_error)
__pyx_L21_unpacking_done:;
}
__Pyx_DECREF_SET(__pyx_v_start, __pyx_t_4);
@@ -69372,32 +68611,32 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* if (numpy.array(stride) < 0).any():
* raise IndexError('negative strides not allowed when slicing MFVariable Variable instance')
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5667, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (likely(PyList_CheckExact(__pyx_v_count)) || PyTuple_CheckExact(__pyx_v_count)) {
__pyx_t_7 = __pyx_v_count; __Pyx_INCREF(__pyx_t_7); __pyx_t_13 = 0;
__pyx_t_14 = NULL;
} else {
- __pyx_t_13 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_count); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_v_count); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5667, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_14 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5667, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_14)) {
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_2); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_2); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 5667, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5667, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_13 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_2); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_2); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 5667, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5667, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -69407,7 +68646,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5667, __pyx_L1_error)
}
break;
}
@@ -69415,9 +68654,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
__Pyx_DECREF_SET(__pyx_v_cnt, __pyx_t_2);
__pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Absolute(__pyx_v_cnt); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Absolute(__pyx_v_cnt); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5667, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5667; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_2))) __PYX_ERR(0, 5667, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
@@ -69431,9 +68670,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* raise IndexError('negative strides not allowed when slicing MFVariable Variable instance')
* # Start, stop and step along 1st dimension, eg the unlimited
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -69447,23 +68686,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_2) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_stride); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_stride); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_stride);
__Pyx_GIVEREF(__pyx_v_stride);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_stride);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyObject_RichCompare(__pyx_t_7, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_any); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_any); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
@@ -69477,14 +68716,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (__pyx_t_3) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5668, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 5668, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_10) {
@@ -69495,11 +68734,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* # Start, stop and step along 1st dimension, eg the unlimited
* # dimension.
*/
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__123, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__116, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5669, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5669, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5668
* # make sure count=-1 becomes count=1
@@ -69517,7 +68756,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* step = stride[0]
* stop = sta + count[0] * step
*/
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_start, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5672; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_start, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5672, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_sta, __pyx_t_1);
__pyx_t_1 = 0;
@@ -69529,7 +68768,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* stop = sta + count[0] * step
*
*/
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_stride, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5673; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_stride, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_step, __pyx_t_1);
__pyx_t_1 = 0;
@@ -69541,12 +68780,12 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # Build a list representing the concatenated list of all records in
*/
- __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_count, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5674; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_count, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5674, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = PyNumber_Multiply(__pyx_t_1, __pyx_v_step); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyNumber_Multiply(__pyx_t_1, __pyx_v_step); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5674, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_Add(__pyx_v_sta, __pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5674; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_v_sta, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5674, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF_SET(__pyx_v_stop, __pyx_t_1);
@@ -69559,7 +68798,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* vid = [] # list of Variable indices
* for n in range(nv):
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5681; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5681, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_idx, ((PyObject*)__pyx_t_1));
__pyx_t_1 = 0;
@@ -69571,7 +68810,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* for n in range(nv):
* k = self._recLen[n] # number of records in this variable
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5682; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5682, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_vid, ((PyObject*)__pyx_t_1));
__pyx_t_1 = 0;
@@ -69583,23 +68822,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* k = self._recLen[n] # number of records in this variable
* idx.extend(range(k))
*/
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_nv); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_nv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7); __pyx_t_13 = 0;
__pyx_t_14 = NULL;
} else {
- __pyx_t_13 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_14 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5683, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -69607,17 +68846,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_1); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_1); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 5683, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_13 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_1); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_13); __Pyx_INCREF(__pyx_t_1); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 5683, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_7, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5683, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -69627,7 +68866,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5683; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5683, __pyx_L1_error)
}
break;
}
@@ -69643,9 +68882,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* idx.extend(range(k))
* vid.extend([n] * k)
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recLen); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5684; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recLen); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = PyObject_GetItem(__pyx_t_1, __pyx_v_n); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5684; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_t_1, __pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_k, __pyx_t_3);
@@ -69658,15 +68897,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* vid.extend([n] * k)
*
*/
- __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5685, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_k);
__Pyx_GIVEREF(__pyx_v_k);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_k);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5685, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_15 = __Pyx_PyList_Extend(__pyx_v_idx, __pyx_t_1); if (unlikely(__pyx_t_15 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5685; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyList_Extend(__pyx_v_idx, __pyx_t_1); if (unlikely(__pyx_t_15 == -1)) __PYX_ERR(0, 5685, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5686
@@ -69676,17 +68915,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # Merge the two lists to get a list of 2-elem lists.
*/
- __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5686; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5686, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_n);
__Pyx_GIVEREF(__pyx_v_n);
PyList_SET_ITEM(__pyx_t_1, 0, __pyx_v_n);
- { PyObject* __pyx_temp = PyNumber_InPlaceMultiply(__pyx_t_1, __pyx_v_k); if (unlikely(!__pyx_temp)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5686; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ { PyObject* __pyx_temp = PyNumber_InPlaceMultiply(__pyx_t_1, __pyx_v_k); if (unlikely(!__pyx_temp)) __PYX_ERR(0, 5686, __pyx_L1_error)
__Pyx_GOTREF(__pyx_temp);
__Pyx_DECREF(__pyx_t_1);
__pyx_t_1 = __pyx_temp;
}
- __pyx_t_15 = __Pyx_PyList_Extend(__pyx_v_vid, __pyx_t_1); if (unlikely(__pyx_t_15 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5686; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyList_Extend(__pyx_v_vid, __pyx_t_1); if (unlikely(__pyx_t_15 == -1)) __PYX_ERR(0, 5686, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5683
@@ -69706,7 +68945,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # Rebuild the slicing expression for dimensions 1 and ssq.
*/
- __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_zip); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
__pyx_t_13 = 0;
@@ -69720,7 +68959,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__pyx_t_13 = 1;
}
}
- __pyx_t_2 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); __pyx_t_4 = NULL;
@@ -69731,17 +68970,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_INCREF(__pyx_v_vid);
__Pyx_GIVEREF(__pyx_v_vid);
PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_13, __pyx_v_vid);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_List(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_getitem); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_getitem); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- __pyx_t_3 = PySlice_New(__pyx_v_sta, __pyx_v_stop, __pyx_v_step); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySlice_New(__pyx_v_sta, __pyx_v_stop, __pyx_v_step); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_2 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -69754,17 +68993,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_2) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else {
- __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5690; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5690, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
@@ -69779,11 +69018,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* for n in range(1, len(start)): # skip dimension 0
* s = slice(start[n],start[n] + count[n] * stride[n], stride[n])
*/
- __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5693; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5693, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __Pyx_INCREF(__pyx_slice__124);
- __Pyx_GIVEREF(__pyx_slice__124);
- PyList_SET_ITEM(__pyx_t_7, 0, __pyx_slice__124);
+ __Pyx_INCREF(__pyx_slice__117);
+ __Pyx_GIVEREF(__pyx_slice__117);
+ PyList_SET_ITEM(__pyx_t_7, 0, __pyx_slice__117);
__Pyx_XDECREF_SET(__pyx_v_newSlice, ((PyObject*)__pyx_t_7));
__pyx_t_7 = 0;
@@ -69794,10 +69033,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* s = slice(start[n],start[n] + count[n] * stride[n], stride[n])
* newSlice.append(s)
*/
- __pyx_t_13 = PyObject_Length(__pyx_v_start); if (unlikely(__pyx_t_13 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = PyObject_Length(__pyx_v_start); if (unlikely(__pyx_t_13 == -1)) __PYX_ERR(0, 5694, __pyx_L1_error)
+ __pyx_t_7 = PyInt_FromSsize_t(__pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_int_1);
__Pyx_GIVEREF(__pyx_int_1);
@@ -69805,16 +69044,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_7);
__pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_1, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (likely(PyList_CheckExact(__pyx_t_7)) || PyTuple_CheckExact(__pyx_t_7)) {
__pyx_t_1 = __pyx_t_7; __Pyx_INCREF(__pyx_t_1); __pyx_t_13 = 0;
__pyx_t_14 = NULL;
} else {
- __pyx_t_13 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_14 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5694, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
for (;;) {
@@ -69822,17 +69061,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_13); __Pyx_INCREF(__pyx_t_7); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_13); __Pyx_INCREF(__pyx_t_7); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 5694, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_13 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_13); __Pyx_INCREF(__pyx_t_7); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_13); __Pyx_INCREF(__pyx_t_7); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 5694, __pyx_L1_error)
#else
- __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(__pyx_t_1, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5694, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
@@ -69842,7 +69081,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5694; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5694, __pyx_L1_error)
}
break;
}
@@ -69858,25 +69097,25 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* newSlice.append(s)
*
*/
- __pyx_t_7 = PyObject_GetItem(__pyx_v_start, __pyx_v_n); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5695; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_7 = PyObject_GetItem(__pyx_v_start, __pyx_v_n); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_4 = PyObject_GetItem(__pyx_v_start, __pyx_v_n); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5695; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_4 = PyObject_GetItem(__pyx_v_start, __pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_3 = PyObject_GetItem(__pyx_v_count, __pyx_v_n); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5695; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_v_count, __pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5695; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_12 = PyNumber_Multiply(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5695; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyNumber_Multiply(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_t_12); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5695; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Add(__pyx_t_4, __pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
- __pyx_t_12 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(__pyx_t_12 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5695; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_12 = PyObject_GetItem(__pyx_v_stride, __pyx_v_n); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
- __pyx_t_4 = PySlice_New(__pyx_t_7, __pyx_t_2, __pyx_t_12); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5695; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySlice_New(__pyx_t_7, __pyx_t_2, __pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5695, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -69891,7 +69130,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # Apply the slicing expression to each var in turn, extracting records
*/
- __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_newSlice, __pyx_v_s); if (unlikely(__pyx_t_15 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5696; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_newSlice, __pyx_v_s); if (unlikely(__pyx_t_15 == -1)) __PYX_ERR(0, 5696, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5694
* # Rebuild the slicing expression for dimensions 1 and ssq.
@@ -69910,7 +69149,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* ismasked = False
* for n in range(nv):
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5700; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5700, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_lstArr, __pyx_t_1);
__pyx_t_1 = 0;
@@ -69931,23 +69170,23 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* # Get the list of indices for variable 'n'.
* idx = [i for i,numv in lst if numv == n]
*/
- __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_nv); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_nv); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1);
__pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_range, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
__pyx_t_4 = __pyx_t_1; __Pyx_INCREF(__pyx_t_4); __pyx_t_13 = 0;
__pyx_t_14 = NULL;
} else {
- __pyx_t_13 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_13 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_14 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5702, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -69955,17 +69194,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
if (likely(PyList_CheckExact(__pyx_t_4))) {
if (__pyx_t_13 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_13); __Pyx_INCREF(__pyx_t_1); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_13); __Pyx_INCREF(__pyx_t_1); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 5702, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_13 >= PyTuple_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_13); __Pyx_INCREF(__pyx_t_1); __pyx_t_13++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_13); __Pyx_INCREF(__pyx_t_1); __pyx_t_13++; if (unlikely(0 < 0)) __PYX_ERR(0, 5702, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_13); __pyx_t_13++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5702, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -69975,7 +69214,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5702; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5702, __pyx_L1_error)
}
break;
}
@@ -69991,32 +69230,32 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* if idx:
* # Rebuild slicing expression for dimension 0.
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (likely(PyList_CheckExact(__pyx_v_lst)) || PyTuple_CheckExact(__pyx_v_lst)) {
__pyx_t_12 = __pyx_v_lst; __Pyx_INCREF(__pyx_t_12); __pyx_t_16 = 0;
__pyx_t_17 = NULL;
} else {
- __pyx_t_16 = -1; __pyx_t_12 = PyObject_GetIter(__pyx_v_lst); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_16 = -1; __pyx_t_12 = PyObject_GetIter(__pyx_v_lst); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
- __pyx_t_17 = Py_TYPE(__pyx_t_12)->tp_iternext; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_17 = Py_TYPE(__pyx_t_12)->tp_iternext; if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 5704, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_17)) {
if (likely(PyList_CheckExact(__pyx_t_12))) {
if (__pyx_t_16 >= PyList_GET_SIZE(__pyx_t_12)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyList_GET_ITEM(__pyx_t_12, __pyx_t_16); __Pyx_INCREF(__pyx_t_2); __pyx_t_16++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_12, __pyx_t_16); __Pyx_INCREF(__pyx_t_2); __pyx_t_16++; if (unlikely(0 < 0)) __PYX_ERR(0, 5704, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_12, __pyx_t_16); __pyx_t_16++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_12, __pyx_t_16); __pyx_t_16++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
} else {
if (__pyx_t_16 >= PyTuple_GET_SIZE(__pyx_t_12)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_12, __pyx_t_16); __Pyx_INCREF(__pyx_t_2); __pyx_t_16++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_12, __pyx_t_16); __Pyx_INCREF(__pyx_t_2); __pyx_t_16++; if (unlikely(0 < 0)) __PYX_ERR(0, 5704, __pyx_L1_error)
#else
- __pyx_t_2 = PySequence_ITEM(__pyx_t_12, __pyx_t_16); __pyx_t_16++; if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_12, __pyx_t_16); __pyx_t_16++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
}
@@ -70026,7 +69265,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5704, __pyx_L1_error)
}
break;
}
@@ -70042,7 +69281,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5704, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -70055,15 +69294,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_3);
#else
- __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_18 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5704, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_18)->tp_iternext;
@@ -70071,7 +69310,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_GOTREF(__pyx_t_7);
index = 1; __pyx_t_3 = __pyx_t_8(__pyx_t_18); if (unlikely(!__pyx_t_3)) goto __pyx_L33_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_18), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_18), 2) < 0) __PYX_ERR(0, 5704, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
goto __pyx_L34_unpacking_done;
@@ -70079,18 +69318,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5704, __pyx_L1_error)
__pyx_L34_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_7);
__pyx_t_7 = 0;
__Pyx_XDECREF_SET(__pyx_v_numv, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_2 = PyObject_RichCompare(__pyx_v_numv, __pyx_v_n, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyObject_RichCompare(__pyx_v_numv, __pyx_v_n, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5704, __pyx_L1_error)
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 5704, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_10) {
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_v_i))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5704; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_v_i))) __PYX_ERR(0, 5704, __pyx_L1_error)
}
}
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
@@ -70114,18 +69353,18 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* # Extract records from the var, and append them to a list
* # of arrays.
*/
- __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_idx, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5707; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_idx, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5707, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = __Pyx_GetItemInt_List(__pyx_v_idx, -1L, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(__pyx_t_12 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5707; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_12 = __Pyx_GetItemInt_List(__pyx_v_idx, -1L, long, 1, __Pyx_PyInt_From_long, 1, 1, 1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5707, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
- __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_12, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_t_12, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5707, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
- __pyx_t_12 = PySlice_New(__pyx_t_1, __pyx_t_2, __pyx_v_step); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PySlice_New(__pyx_t_1, __pyx_t_2, __pyx_v_step); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5707, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (unlikely(__Pyx_SetItemInt(__pyx_v_newSlice, 0, __pyx_t_12, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_SetItemInt(__pyx_v_newSlice, 0, __pyx_t_12, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(0, 5707, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
/* "netCDF4/_netCDF4.pyx":5710
@@ -70135,14 +69374,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* if ma.isMA(dat) and not ismasked:
* ismasked=True
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_n_s_getitem); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Variable), __pyx_n_s_getitem); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5710, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5710, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = PyObject_GetItem(__pyx_t_1, __pyx_v_n); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5710; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_t_1, __pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5710, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyList_AsTuple(__pyx_v_newSlice); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_AsTuple(__pyx_v_newSlice); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5710, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_7 = NULL;
__pyx_t_16 = 0;
@@ -70156,7 +69395,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__pyx_t_16 = 1;
}
}
- __pyx_t_18 = PyTuple_New(2+__pyx_t_16); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = PyTuple_New(2+__pyx_t_16); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5710, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_18);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -70167,7 +69406,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_16, __pyx_t_1);
__pyx_t_3 = 0;
__pyx_t_1 = 0;
- __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_18, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_18, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5710, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -70181,9 +69420,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* ismasked=True
* fill_value = dat.fill_value
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isMA); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_isMA); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -70197,21 +69436,21 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_2) {
- __pyx_t_12 = __Pyx_PyObject_CallOneArg(__pyx_t_18, __pyx_v_dat); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_CallOneArg(__pyx_t_18, __pyx_v_dat); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
} else {
- __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_v_dat);
__Pyx_GIVEREF(__pyx_v_dat);
PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_v_dat);
- __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_18, __pyx_t_1, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_18, __pyx_t_1, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5711; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5711, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
if (__pyx_t_11) {
} else {
@@ -70239,7 +69478,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* lstArr.append(dat)
* if ismasked:
*/
- __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_dat, __pyx_n_s_fill_value); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5713; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_dat, __pyx_n_s_fill_value); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5713, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_XDECREF_SET(__pyx_v_fill_value, __pyx_t_12);
__pyx_t_12 = 0;
@@ -70260,7 +69499,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* if ismasked:
* lstArr = ma.concatenate(lstArr)
*/
- __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_lstArr, __pyx_v_dat); if (unlikely(__pyx_t_15 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5714; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_Append(__pyx_v_lstArr, __pyx_v_dat); if (unlikely(__pyx_t_15 == -1)) __PYX_ERR(0, 5714, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5705
* # Get the list of indices for variable 'n'.
@@ -70298,9 +69537,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* else:
* lstArr = numpy.concatenate(lstArr)
*/
- __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5716; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5716, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
- __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_concatenate); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5716; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_concatenate); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5716, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__pyx_t_12 = NULL;
@@ -70314,16 +69553,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_12) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_18, __pyx_v_lstArr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5716; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_18, __pyx_v_lstArr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5716, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
- __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5716; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5716, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_INCREF(__pyx_v_lstArr);
__Pyx_GIVEREF(__pyx_v_lstArr);
PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_v_lstArr);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_18, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5716; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_18, __pyx_t_1, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5716, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
@@ -70349,9 +69588,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* # sometimes there are legitimate singleton dimensions, in which
*/
/*else*/ {
- __pyx_t_18 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_18 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 5718, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_18);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_concatenate); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_n_s_concatenate); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5718, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__pyx_t_18 = NULL;
@@ -70365,16 +69604,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_18) {
- __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_lstArr); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_lstArr); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5718, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
- __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5718, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_18); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_18); __pyx_t_18 = NULL;
__Pyx_INCREF(__pyx_v_lstArr);
__Pyx_GIVEREF(__pyx_v_lstArr);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_v_lstArr);
- __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5718; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5718, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
@@ -70391,19 +69630,19 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* # sometimes there are legitimate singleton dimensions, in which
* # case the array shapes won't conform. If so, a ValueError will
*/
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_lstArr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_lstArr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyObject_RichCompare(__pyx_t_4, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
if (__pyx_t_10) {
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_astype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_astype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_lstArr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_lstArr, __pyx_n_s_dtype); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_18 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -70416,17 +69655,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_18) {
- __pyx_t_12 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_12);
} else {
- __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyTuple_New(1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_18); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_18); __pyx_t_18 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_2, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
- __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5719, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
@@ -70443,6 +69682,8 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* except ValueError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
@@ -70456,7 +69697,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* except ValueError:
* data[tuple(ind)] = lstArr
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_lstArr, __pyx_n_s_squeeze); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5724; __pyx_clineno = __LINE__; goto __pyx_L42_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_lstArr, __pyx_n_s_squeeze); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5724, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) {
@@ -70469,16 +69710,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (__pyx_t_2) {
- __pyx_t_12 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5724; __pyx_clineno = __LINE__; goto __pyx_L42_error;}
+ __pyx_t_12 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5724, __pyx_L42_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_12 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5724; __pyx_clineno = __LINE__; goto __pyx_L42_error;}
+ __pyx_t_12 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5724, __pyx_L42_error)
}
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PySequence_Tuple(__pyx_v_ind); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5724; __pyx_clineno = __LINE__; goto __pyx_L42_error;}
+ __pyx_t_1 = PySequence_Tuple(__pyx_v_ind); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5724, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(PyObject_SetItem(__pyx_v_data, __pyx_t_1, __pyx_t_12) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5724; __pyx_clineno = __LINE__; goto __pyx_L42_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_data, __pyx_t_1, __pyx_t_12) < 0)) __PYX_ERR(0, 5724, __pyx_L42_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
@@ -70495,6 +69736,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
__Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
goto __pyx_L49_try_end;
__pyx_L42_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
@@ -70510,10 +69752,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* data[tuple(ind)] = lstArr
*
*/
- __pyx_t_22 = PyErr_ExceptionMatches(__pyx_builtin_ValueError);
+ __pyx_t_22 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError);
if (__pyx_t_22) {
__Pyx_AddTraceback("netCDF4._netCDF4._Variable.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_1, &__pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5725; __pyx_clineno = __LINE__; goto __pyx_L44_except_error;}
+ if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(0, 5725, __pyx_L44_except_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_2);
@@ -70525,9 +69767,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # Remove extra singleton dimensions.
*/
- __pyx_t_4 = PySequence_Tuple(__pyx_v_ind); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5726; __pyx_clineno = __LINE__; goto __pyx_L44_except_error;}
+ __pyx_t_4 = PySequence_Tuple(__pyx_v_ind); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5726, __pyx_L44_except_error)
__Pyx_GOTREF(__pyx_t_4);
- if (unlikely(PyObject_SetItem(__pyx_v_data, __pyx_t_4, __pyx_v_lstArr) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5726; __pyx_clineno = __LINE__; goto __pyx_L44_except_error;}
+ if (unlikely(PyObject_SetItem(__pyx_v_data, __pyx_t_4, __pyx_v_lstArr) < 0)) __PYX_ERR(0, 5726, __pyx_L44_except_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
@@ -70544,12 +69786,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* data[tuple(ind)] = lstArr.squeeze()
* except ValueError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
goto __pyx_L1_error;
__pyx_L43_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
@@ -70574,9 +69818,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* # if no masked elements, return numpy array.
*/
- __pyx_t_6 = PySequence_Tuple(__pyx_v_squeeze); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5729; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_Tuple(__pyx_v_squeeze); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5729, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_2 = PyObject_GetItem(__pyx_v_data, __pyx_t_6); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5729; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_v_data, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5729, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_2);
@@ -70589,9 +69833,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
* data = data.filled()
*
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_ma); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isMA); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_isMA); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
@@ -70605,30 +69849,30 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (!__pyx_t_6) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_data); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
- __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_v_data);
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_12, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_11) {
} else {
__pyx_t_10 = __pyx_t_11;
goto __pyx_L53_bool_binop_done;
}
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_mask); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_mask); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_any); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_any); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
@@ -70642,14 +69886,14 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (__pyx_t_1) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_12); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5732, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
- __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_11 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5732; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(0, 5732, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_23 = ((!__pyx_t_11) != 0);
__pyx_t_10 = __pyx_t_23;
@@ -70663,7 +69907,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
*
* return data
*/
- __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_filled); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5733; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_data, __pyx_n_s_filled); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 5733, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_1 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_12))) {
@@ -70676,10 +69920,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_9_Variable_16__getitem__(CYTHON_UNU
}
}
if (__pyx_t_1) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5733; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5733, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_12); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5733; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_12); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5733, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
@@ -70775,9 +70019,6 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_6MFTime_1__init__(PyObject *__pyx_s
PyObject *__pyx_v_self = 0;
PyObject *__pyx_v_time = 0;
PyObject *__pyx_v_units = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
@@ -70803,7 +70044,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_6MFTime_1__init__(PyObject *__pyx_s
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_time)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5773; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, 1); __PYX_ERR(0, 5773, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
@@ -70812,7 +70053,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_6MFTime_1__init__(PyObject *__pyx_s
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5773; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 5773, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
@@ -70829,7 +70070,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_6MFTime_1__init__(PyObject *__pyx_s
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5773; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5773, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.MFTime.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -70871,9 +70112,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
PyObject *__pyx_t_12 = NULL;
Py_ssize_t __pyx_t_13;
PyObject *__pyx_t_14 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__init__", 0);
/* "netCDF4/_netCDF4.pyx":5785
@@ -70883,7 +70121,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* self.__time = time
*
*/
- __pyx_t_1 = __Pyx_Import(__pyx_n_s_datetime, 0, -1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5785; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_Import(__pyx_n_s_datetime, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5785, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_datetime = __pyx_t_1;
__pyx_t_1 = 0;
@@ -70895,7 +70133,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*
* # copy attributes from master time variable.
*/
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__time, __pyx_v_time) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5786; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__time, __pyx_v_time) < 0) __PYX_ERR(0, 5786, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5789
*
@@ -70904,9 +70142,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* self.__dict__[name] = value
*
*/
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_time, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_time, __pyx_n_s_dict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_items); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = NULL;
@@ -70920,10 +70158,10 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
}
}
if (__pyx_t_2) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5789, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -70931,9 +70169,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
__pyx_t_3 = __pyx_t_1; __Pyx_INCREF(__pyx_t_3); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5789, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
@@ -70941,17 +70179,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
if (likely(PyList_CheckExact(__pyx_t_3))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5789, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_3)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_4); __Pyx_INCREF(__pyx_t_1); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5789, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_3, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
@@ -70961,7 +70199,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5789, __pyx_L1_error)
}
break;
}
@@ -70977,7 +70215,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5789, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
@@ -70990,15 +70228,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
#else
- __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5789, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext;
@@ -71006,7 +70244,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
__Pyx_GOTREF(__pyx_t_2);
index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed;
__Pyx_GOTREF(__pyx_t_6);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < 0) __PYX_ERR(0, 5789, __pyx_L1_error)
__pyx_t_8 = NULL;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L6_unpacking_done;
@@ -71014,7 +70252,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_8 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5789; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5789, __pyx_L1_error)
__pyx_L6_unpacking_done:;
}
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_2);
@@ -71029,9 +70267,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*
* # make sure calendar attribute present in all files.
*/
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5790; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5790, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_name, __pyx_v_value) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5790; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_name, __pyx_v_value) < 0)) __PYX_ERR(0, 5790, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5789
@@ -71051,15 +70289,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* if not hasattr(t,'calendar'):
* raise ValueError('MFTime requires that the time variable in all files have a calendar attribute')
*/
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5793, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
__pyx_t_1 = __pyx_t_3; __Pyx_INCREF(__pyx_t_1); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5793, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5793, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
for (;;) {
@@ -71067,17 +70305,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5793, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5793, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5793, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5793, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
}
@@ -71087,7 +70325,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5793; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5793, __pyx_L1_error)
}
break;
}
@@ -71103,7 +70341,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* raise ValueError('MFTime requires that the time variable in all files have a calendar attribute')
*
*/
- __pyx_t_9 = PyObject_HasAttr(__pyx_v_t, __pyx_n_s_calendar); if (unlikely(__pyx_t_9 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5794; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_9 = PyObject_HasAttr(__pyx_v_t, __pyx_n_s_calendar); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 5794, __pyx_L1_error)
__pyx_t_10 = ((!(__pyx_t_9 != 0)) != 0);
if (__pyx_t_10) {
@@ -71114,11 +70352,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*
* # Check that calendar is the same in all files.
*/
- __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__125, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__118, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5795, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5795, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5794
* # make sure calendar attribute present in all files.
@@ -71146,17 +70384,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* raise ValueError('MFTime requires that the same time calendar is used by all files.')
*
*/
- __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (likely(PyList_CheckExact(__pyx_t_3)) || PyTuple_CheckExact(__pyx_t_3)) {
__pyx_t_6 = __pyx_t_3; __Pyx_INCREF(__pyx_t_6); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_5 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5798, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
for (;;) {
@@ -71164,17 +70402,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
if (likely(PyList_CheckExact(__pyx_t_6))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5798, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_4); __Pyx_INCREF(__pyx_t_3); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5798, __pyx_L1_error)
#else
- __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_6, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
}
@@ -71184,7 +70422,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5798, __pyx_L1_error)
}
break;
}
@@ -71192,16 +70430,16 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
}
__Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_3);
__pyx_t_3 = 0;
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_calendar); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_calendar); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_6 = PySet_New(__pyx_t_1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = PySet_New(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_4 = PySet_GET_SIZE(__pyx_t_6); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5798; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PySet_GET_SIZE(__pyx_t_6); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 5798, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_10 = ((__pyx_t_4 > 1) != 0);
if (__pyx_t_10) {
@@ -71213,11 +70451,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*
* # Override units if units is specified.
*/
- __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__126, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__119, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5799, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 5799, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5798
*
@@ -71235,20 +70473,20 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*
* # Reference date to compute the difference between different time units.
*/
- __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_units); if (unlikely(__pyx_t_10 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5802; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_v_units); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(0, 5802, __pyx_L1_error)
if (!__pyx_t_10) {
} else {
__Pyx_INCREF(__pyx_v_units);
__pyx_t_6 = __pyx_v_units;
goto __pyx_L13_bool_binop_done;
}
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_time, __pyx_n_s_units); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5802; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_time, __pyx_n_s_units); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5802, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_1);
__pyx_t_6 = __pyx_t_1;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_L13_bool_binop_done:;
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_units, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5802; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_units, __pyx_t_6) < 0) __PYX_ERR(0, 5802, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "netCDF4/_netCDF4.pyx":5805
@@ -71258,9 +70496,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* ref_num = date2num(ref_date, self.units, self.calendar)
*
*/
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_datetime, __pyx_n_s_datetime); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_datetime, __pyx_n_s_datetime); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5805, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__127, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple__120, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5805, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_v_ref_date = __pyx_t_1;
@@ -71273,11 +70511,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*
* # Create delta vector: delta = ref_num(ref_date) - num(ref_date)
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_date2num); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_date2num); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5806, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_units); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_units); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5806, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_calendar); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_calendar); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5806, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_7 = NULL;
__pyx_t_4 = 0;
@@ -71291,7 +70529,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
__pyx_t_4 = 1;
}
}
- __pyx_t_11 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(3+__pyx_t_4); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5806, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_7); __pyx_t_7 = NULL;
@@ -71305,7 +70543,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_4, __pyx_t_2);
__pyx_t_3 = 0;
__pyx_t_2 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5806, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
@@ -71319,15 +70557,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*
* i0 = 0; i1 = 0
*/
- __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5810, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_empty); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5810, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
- __pyx_t_4 = PyObject_Length(__pyx_v_self); if (unlikely(__pyx_t_4 == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = PyObject_Length(__pyx_v_self); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(0, 5810, __pyx_L1_error)
+ __pyx_t_6 = PyInt_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5810, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_time, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_time, __pyx_n_s_dtype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5810, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
__pyx_t_4 = 0;
@@ -71341,7 +70579,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
__pyx_t_4 = 1;
}
}
- __pyx_t_7 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyTuple_New(2+__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5810, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_3) {
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
@@ -71352,11 +70590,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_4, __pyx_t_2);
__pyx_t_6 = 0;
__pyx_t_2 = 0;
- __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5810, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__delta, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5810; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__delta, __pyx_t_1) < 0) __PYX_ERR(0, 5810, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "netCDF4/_netCDF4.pyx":5812
@@ -71380,15 +70618,15 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*/
__Pyx_INCREF(__pyx_int_0);
__pyx_t_1 = __pyx_int_0;
- __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recVar); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
if (likely(PyList_CheckExact(__pyx_t_11)) || PyTuple_CheckExact(__pyx_t_11)) {
__pyx_t_7 = __pyx_t_11; __Pyx_INCREF(__pyx_t_7); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
} else {
- __pyx_t_4 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_4 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_5 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_5 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5813, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
for (;;) {
@@ -71396,17 +70634,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_4 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_11 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_4); __Pyx_INCREF(__pyx_t_11); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_4); __Pyx_INCREF(__pyx_t_11); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5813, __pyx_L1_error)
#else
- __pyx_t_11 = PySequence_ITEM(__pyx_t_7, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PySequence_ITEM(__pyx_t_7, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
#endif
} else {
if (__pyx_t_4 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_4); __Pyx_INCREF(__pyx_t_11); __pyx_t_4++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_4); __Pyx_INCREF(__pyx_t_11); __pyx_t_4++; if (unlikely(0 < 0)) __PYX_ERR(0, 5813, __pyx_L1_error)
#else
- __pyx_t_11 = PySequence_ITEM(__pyx_t_7, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PySequence_ITEM(__pyx_t_7, __pyx_t_4); __pyx_t_4++; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
#endif
}
@@ -71416,7 +70654,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 5813, __pyx_L1_error)
}
break;
}
@@ -71426,7 +70664,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
__pyx_t_11 = 0;
__Pyx_INCREF(__pyx_t_1);
__Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1);
- __pyx_t_11 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5813; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_1);
__pyx_t_1 = __pyx_t_11;
@@ -71439,9 +70677,9 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* num = date2num(ref_date, v.units, self.calendar)
* i1 += n
*/
- __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recLen); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5814; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_recLen); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5814, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
- __pyx_t_2 = PyObject_GetItem(__pyx_t_11, __pyx_v_i); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5814; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_t_11, __pyx_v_i); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5814, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF_SET(__pyx_v_n, __pyx_t_2);
@@ -71454,11 +70692,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* i1 += n
* self.__delta[i0:i1] = ref_num - num
*/
- __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_date2num); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_date2num); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5815, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
- __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_units); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_v, __pyx_n_s_units); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5815, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
- __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_calendar); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_calendar); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5815, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
__pyx_t_13 = 0;
@@ -71472,7 +70710,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
__pyx_t_13 = 1;
}
}
- __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_14 = PyTuple_New(3+__pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 5815, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
if (__pyx_t_12) {
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __pyx_t_12 = NULL;
@@ -71486,7 +70724,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
PyTuple_SET_ITEM(__pyx_t_14, 2+__pyx_t_13, __pyx_t_3);
__pyx_t_6 = 0;
__pyx_t_3 = 0;
- __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_14, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5815; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_14, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5815, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
@@ -71500,7 +70738,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* self.__delta[i0:i1] = ref_num - num
* i0 += n
*/
- __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_i1, __pyx_v_n); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5816; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_i1, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5816, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF_SET(__pyx_v_i1, __pyx_t_2);
__pyx_t_2 = 0;
@@ -71512,11 +70750,11 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
* i0 += n
*
*/
- __pyx_t_2 = PyNumber_Subtract(__pyx_v_ref_num, __pyx_v_num); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5817; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_Subtract(__pyx_v_ref_num, __pyx_v_num); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5817, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__delta); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5817; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__delta); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5817, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_11);
- if (__Pyx_PyObject_SetSlice(__pyx_t_11, __pyx_t_2, 0, 0, &__pyx_v_i0, &__pyx_v_i1, NULL, 0, 0, 1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5817; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_PyObject_SetSlice(__pyx_t_11, __pyx_t_2, 0, 0, &__pyx_v_i0, &__pyx_v_i1, NULL, 0, 0, 1) < 0) __PYX_ERR(0, 5817, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
@@ -71527,7 +70765,7 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime___init__(CYTHON_UNUSED PyOb
*
*
*/
- __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_i0, __pyx_v_n); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5818; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_i0, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5818, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF_SET(__pyx_v_i0, __pyx_t_2);
__pyx_t_2 = 0;
@@ -71596,9 +70834,6 @@ static PyMethodDef __pyx_mdef_7netCDF4_8_netCDF4_6MFTime_3__getitem__ = {"__geti
static PyObject *__pyx_pw_7netCDF4_8_netCDF4_6MFTime_3__getitem__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_self = 0;
PyObject *__pyx_v_elem = 0;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0);
@@ -71622,11 +70857,11 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_6MFTime_3__getitem__(PyObject *__py
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_elem)) != 0)) kw_args--;
else {
- __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5821; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, 1); __PYX_ERR(0, 5821, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
- if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getitem__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5821; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__getitem__") < 0)) __PYX_ERR(0, 5821, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
@@ -71639,7 +70874,7 @@ static PyObject *__pyx_pw_7netCDF4_8_netCDF4_6MFTime_3__getitem__(PyObject *__py
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
- __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5821; __pyx_clineno = __LINE__; goto __pyx_L3_error;}
+ __Pyx_RaiseArgtupleInvalid("__getitem__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 5821, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("netCDF4._netCDF4.MFTime.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
@@ -71658,9 +70893,6 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime_2__getitem__(CYTHON_UNUSED
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
__Pyx_RefNannySetupContext("__getitem__", 0);
/* "netCDF4/_netCDF4.pyx":5822
@@ -71669,17 +70901,17 @@ static PyObject *__pyx_pf_7netCDF4_8_netCDF4_6MFTime_2__getitem__(CYTHON_UNUSED
* return self.__time[elem] + self.__delta[elem] # <<<<<<<<<<<<<<
*/
__Pyx_XDECREF(__pyx_r);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__time); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5822; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__time); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_2 = PyObject_GetItem(__pyx_t_1, __pyx_v_elem); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5822; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_2 = PyObject_GetItem(__pyx_t_1, __pyx_v_elem); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__delta); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5822; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_MFTime__delta); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_3 = PyObject_GetItem(__pyx_t_1, __pyx_v_elem); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5822; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_3 = PyObject_GetItem(__pyx_t_1, __pyx_v_elem); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5822; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
@@ -72115,21 +71347,21 @@ static PyMethodDef __pyx_methods_7netCDF4_8_netCDF4_Dataset[] = {
};
static struct PyGetSetDef __pyx_getsets_7netCDF4_8_netCDF4_Dataset[] = {
- {(char *)"_grpid", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset__grpid, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset__grpid, 0, 0},
- {(char *)"_isopen", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset__isopen, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset__isopen, 0, 0},
- {(char *)"groups", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_groups, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_groups, 0, 0},
- {(char *)"dimensions", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_dimensions, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_dimensions, 0, 0},
- {(char *)"variables", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_variables, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_variables, 0, 0},
- {(char *)"disk_format", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_disk_format, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_disk_format, 0, 0},
- {(char *)"path", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_path, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_path, 0, 0},
- {(char *)"parent", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_parent, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_parent, 0, 0},
- {(char *)"file_format", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_file_format, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_file_format, 0, 0},
- {(char *)"data_model", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_data_model, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_data_model, 0, 0},
- {(char *)"cmptypes", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_cmptypes, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_cmptypes, 0, 0},
- {(char *)"vltypes", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_vltypes, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_vltypes, 0, 0},
- {(char *)"enumtypes", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_enumtypes, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_enumtypes, 0, 0},
- {(char *)"__orthogonal_indexing__", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset___orthogonal_indexing__, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset___orthogonal_indexing__, 0, 0},
- {(char *)"keepweakref", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_keepweakref, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_keepweakref, 0, 0},
+ {(char *)"_grpid", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset__grpid, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset__grpid, (char *)0, 0},
+ {(char *)"_isopen", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset__isopen, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset__isopen, (char *)0, 0},
+ {(char *)"groups", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_groups, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_groups, (char *)0, 0},
+ {(char *)"dimensions", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_dimensions, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_dimensions, (char *)0, 0},
+ {(char *)"variables", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_variables, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_variables, (char *)0, 0},
+ {(char *)"disk_format", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_disk_format, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_disk_format, (char *)0, 0},
+ {(char *)"path", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_path, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_path, (char *)0, 0},
+ {(char *)"parent", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_parent, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_parent, (char *)0, 0},
+ {(char *)"file_format", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_file_format, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_file_format, (char *)0, 0},
+ {(char *)"data_model", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_data_model, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_data_model, (char *)0, 0},
+ {(char *)"cmptypes", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_cmptypes, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_cmptypes, (char *)0, 0},
+ {(char *)"vltypes", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_vltypes, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_vltypes, (char *)0, 0},
+ {(char *)"enumtypes", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_enumtypes, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_enumtypes, (char *)0, 0},
+ {(char *)"__orthogonal_indexing__", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset___orthogonal_indexing__, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset___orthogonal_indexing__, (char *)0, 0},
+ {(char *)"keepweakref", __pyx_getprop_7netCDF4_8_netCDF4_7Dataset_keepweakref, __pyx_setprop_7netCDF4_8_netCDF4_7Dataset_keepweakref, (char *)0, 0},
{0, 0, 0, 0, 0}
};
@@ -72178,7 +71410,7 @@ static PyTypeObject __pyx_type_7netCDF4_8_netCDF4_Dataset = {
__pyx_tp_setattro_7netCDF4_8_netCDF4_Dataset, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
- "\nA netCDF `netCDF4.Dataset` is a collection of dimensions, groups, variables and\nattributes. Together they describe the meaning of data and relations among\ndata fields stored in a netCDF file. See `netCDF4.Dataset.__init__` for more\ndetails.\n\nA list of attribute names corresponding to global netCDF attributes\ndefined for the `netCDF4.Dataset` can be obtained with the\n`netCDF4.Dataset.ncattrs` method.\nThese attributes can be created by assigning to an attribute of the\n`netCDF [...]
+ "\nA netCDF `netCDF4.Dataset` is a collection of dimensions, groups, variables and\nattributes. Together they describe the meaning of data and relations among\ndata fields stored in a netCDF file. See `netCDF4.Dataset.__init__` for more\ndetails.\n\nA list of attribute names corresponding to global netCDF attributes\ndefined for the `netCDF4.Dataset` can be obtained with the\n`netCDF4.Dataset.ncattrs` method.\nThese attributes can be created by assigning to an attribute of the\n`netCDF [...]
__pyx_tp_traverse_7netCDF4_8_netCDF4_Dataset, /*tp_traverse*/
__pyx_tp_clear_7netCDF4_8_netCDF4_Dataset, /*tp_clear*/
0, /*tp_richcompare*/
@@ -72237,7 +71469,7 @@ static PyMethodDef __pyx_methods_7netCDF4_8_netCDF4_Group[] = {
};
static struct PyGetSetDef __pyx_getsets_7netCDF4_8_netCDF4_Group[] = {
- {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_5Group_name, __pyx_setprop_7netCDF4_8_netCDF4_5Group_name, __pyx_k_string_name_of_Group_instance, 0},
+ {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_5Group_name, __pyx_setprop_7netCDF4_8_netCDF4_5Group_name, (char *)"string name of Group instance", 0},
{0, 0, 0, 0, 0}
};
@@ -72467,13 +71699,13 @@ static PyMethodDef __pyx_methods_7netCDF4_8_netCDF4_Dimension[] = {
};
static struct PyGetSetDef __pyx_getsets_7netCDF4_8_netCDF4_Dimension[] = {
- {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension_name, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension_name, __pyx_k_string_name_of_Dimension_instanc, 0},
- {(char *)"size", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension_size, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension_size, __pyx_k_current_size_of_Dimension_calls, 0},
- {(char *)"_dimid", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__dimid, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__dimid, 0, 0},
- {(char *)"_grpid", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__grpid, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__grpid, 0, 0},
- {(char *)"_data_model", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__data_model, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__data_model, 0, 0},
- {(char *)"_name", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__name, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__name, 0, 0},
- {(char *)"_grp", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__grp, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__grp, 0, 0},
+ {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension_name, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension_name, (char *)"string name of Dimension instance", 0},
+ {(char *)"size", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension_size, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension_size, (char *)"current size of Dimension (calls `len` on Dimension instance)", 0},
+ {(char *)"_dimid", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__dimid, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__dimid, (char *)0, 0},
+ {(char *)"_grpid", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__grpid, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__grpid, (char *)0, 0},
+ {(char *)"_data_model", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__data_model, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__data_model, (char *)0, 0},
+ {(char *)"_name", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__name, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__name, (char *)0, 0},
+ {(char *)"_grp", __pyx_getprop_7netCDF4_8_netCDF4_9Dimension__grp, __pyx_setprop_7netCDF4_8_netCDF4_9Dimension__grp, (char *)0, 0},
{0, 0, 0, 0, 0}
};
@@ -73065,29 +72297,29 @@ static PyMethodDef __pyx_methods_7netCDF4_8_netCDF4_Variable[] = {
};
static struct PyGetSetDef __pyx_getsets_7netCDF4_8_netCDF4_Variable[] = {
- {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_name, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_name, __pyx_k_string_name_of_Variable_instance, 0},
- {(char *)"datatype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_datatype, 0, __pyx_k_numpy_data_type_for_primitive_da, 0},
- {(char *)"shape", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_shape, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_shape, __pyx_k_find_current_sizes_of_all_variab, 0},
- {(char *)"size", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_size, 0, __pyx_k_Return_the_number_of_stored_elem, 0},
- {(char *)"dimensions", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_dimensions, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_dimensions, __pyx_k_get_variables_s_dimension_names, 0},
- {(char *)"_varid", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__varid, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__varid, 0, 0},
- {(char *)"_grpid", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__grpid, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__grpid, 0, 0},
- {(char *)"_nunlimdim", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__nunlimdim, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__nunlimdim, 0, 0},
- {(char *)"_name", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__name, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__name, 0, 0},
- {(char *)"ndim", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_ndim, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_ndim, 0, 0},
- {(char *)"dtype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_dtype, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_dtype, 0, 0},
- {(char *)"mask", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_mask, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_mask, 0, 0},
- {(char *)"scale", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_scale, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_scale, 0, 0},
- {(char *)"_isprimitive", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__isprimitive, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__isprimitive, 0, 0},
- {(char *)"_iscompound", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__iscompound, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__iscompound, 0, 0},
- {(char *)"_isvlen", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__isvlen, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__isvlen, 0, 0},
- {(char *)"_isenum", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__isenum, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__isenum, 0, 0},
- {(char *)"_grp", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__grp, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__grp, 0, 0},
- {(char *)"_cmptype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__cmptype, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__cmptype, 0, 0},
- {(char *)"_vltype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__vltype, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__vltype, 0, 0},
- {(char *)"_enumtype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__enumtype, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__enumtype, 0, 0},
- {(char *)"__orthogonal_indexing__", __pyx_getprop_7netCDF4_8_netCDF4_8Variable___orthogonal_indexing__, __pyx_setprop_7netCDF4_8_netCDF4_8Variable___orthogonal_indexing__, 0, 0},
- {(char *)"_has_lsd", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__has_lsd, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__has_lsd, 0, 0},
+ {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_name, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_name, (char *)"string name of Variable instance", 0},
+ {(char *)"datatype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_datatype, 0, (char *)"numpy data type (for primitive data types) or\n VLType/CompoundType/EnumType instance \n (for compound, vlen or enum data types)", 0},
+ {(char *)"shape", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_shape, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_shape, (char *)"find current sizes of all variable dimensions", 0},
+ {(char *)"size", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_size, 0, (char *)"Return the number of stored elements.", 0},
+ {(char *)"dimensions", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_dimensions, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_dimensions, (char *)"get variables's dimension names", 0},
+ {(char *)"_varid", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__varid, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__varid, (char *)0, 0},
+ {(char *)"_grpid", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__grpid, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__grpid, (char *)0, 0},
+ {(char *)"_nunlimdim", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__nunlimdim, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__nunlimdim, (char *)0, 0},
+ {(char *)"_name", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__name, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__name, (char *)0, 0},
+ {(char *)"ndim", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_ndim, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_ndim, (char *)0, 0},
+ {(char *)"dtype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_dtype, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_dtype, (char *)0, 0},
+ {(char *)"mask", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_mask, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_mask, (char *)0, 0},
+ {(char *)"scale", __pyx_getprop_7netCDF4_8_netCDF4_8Variable_scale, __pyx_setprop_7netCDF4_8_netCDF4_8Variable_scale, (char *)0, 0},
+ {(char *)"_isprimitive", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__isprimitive, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__isprimitive, (char *)0, 0},
+ {(char *)"_iscompound", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__iscompound, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__iscompound, (char *)0, 0},
+ {(char *)"_isvlen", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__isvlen, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__isvlen, (char *)0, 0},
+ {(char *)"_isenum", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__isenum, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__isenum, (char *)0, 0},
+ {(char *)"_grp", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__grp, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__grp, (char *)0, 0},
+ {(char *)"_cmptype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__cmptype, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__cmptype, (char *)0, 0},
+ {(char *)"_vltype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__vltype, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__vltype, (char *)0, 0},
+ {(char *)"_enumtype", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__enumtype, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__enumtype, (char *)0, 0},
+ {(char *)"__orthogonal_indexing__", __pyx_getprop_7netCDF4_8_netCDF4_8Variable___orthogonal_indexing__, __pyx_setprop_7netCDF4_8_netCDF4_8Variable___orthogonal_indexing__, (char *)0, 0},
+ {(char *)"_has_lsd", __pyx_getprop_7netCDF4_8_netCDF4_8Variable__has_lsd, __pyx_setprop_7netCDF4_8_netCDF4_8Variable__has_lsd, (char *)0, 0},
{0, 0, 0, 0, 0}
};
@@ -73136,7 +72368,7 @@ static PyTypeObject __pyx_type_7netCDF4_8_netCDF4_Variable = {
__pyx_tp_setattro_7netCDF4_8_netCDF4_Variable, /*tp_setattro*/
0, /*tp_as_buffer*/
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/
- "\nA netCDF `netCDF4.Variable` is used to read and write netCDF data. They are\nanalogous to numpy array objects. See `netCDF4.Variable.__init__` for more\ndetails.\n\nA list of attribute names corresponding to netCDF attributes defined for\nthe variable can be obtained with the `netCDF4.Variable.ncattrs` method. These\nattributes can be created by assigning to an attribute of the\n`netCDF4.Variable` instance. A dictionary containing all the netCDF attribute\nname/value pairs is provi [...]
+ "\nA netCDF `netCDF4.Variable` is used to read and write netCDF data. They are\nanalogous to numpy array objects. See `netCDF4.Variable.__init__` for more\ndetails.\n\nA list of attribute names corresponding to netCDF attributes defined for\nthe variable can be obtained with the `netCDF4.Variable.ncattrs` method. These\nattributes can be created by assigning to an attribute of the\n`netCDF4.Variable` instance. A dictionary containing all the netCDF attribute\nname/value pairs is provi [...]
__pyx_tp_traverse_7netCDF4_8_netCDF4_Variable, /*tp_traverse*/
__pyx_tp_clear_7netCDF4_8_netCDF4_Variable, /*tp_clear*/
0, /*tp_richcompare*/
@@ -73266,9 +72498,9 @@ static PyMethodDef __pyx_methods_7netCDF4_8_netCDF4_CompoundType[] = {
};
static struct PyGetSetDef __pyx_getsets_7netCDF4_8_netCDF4_CompoundType[] = {
- {(char *)"_nc_type", __pyx_getprop_7netCDF4_8_netCDF4_12CompoundType__nc_type, __pyx_setprop_7netCDF4_8_netCDF4_12CompoundType__nc_type, 0, 0},
- {(char *)"dtype", __pyx_getprop_7netCDF4_8_netCDF4_12CompoundType_dtype, __pyx_setprop_7netCDF4_8_netCDF4_12CompoundType_dtype, 0, 0},
- {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_12CompoundType_name, __pyx_setprop_7netCDF4_8_netCDF4_12CompoundType_name, 0, 0},
+ {(char *)"_nc_type", __pyx_getprop_7netCDF4_8_netCDF4_12CompoundType__nc_type, __pyx_setprop_7netCDF4_8_netCDF4_12CompoundType__nc_type, (char *)0, 0},
+ {(char *)"dtype", __pyx_getprop_7netCDF4_8_netCDF4_12CompoundType_dtype, __pyx_setprop_7netCDF4_8_netCDF4_12CompoundType_dtype, (char *)0, 0},
+ {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_12CompoundType_name, __pyx_setprop_7netCDF4_8_netCDF4_12CompoundType_name, (char *)0, 0},
{0, 0, 0, 0, 0}
};
@@ -73428,9 +72660,9 @@ static PyMethodDef __pyx_methods_7netCDF4_8_netCDF4_VLType[] = {
};
static struct PyGetSetDef __pyx_getsets_7netCDF4_8_netCDF4_VLType[] = {
- {(char *)"_nc_type", __pyx_getprop_7netCDF4_8_netCDF4_6VLType__nc_type, __pyx_setprop_7netCDF4_8_netCDF4_6VLType__nc_type, 0, 0},
- {(char *)"dtype", __pyx_getprop_7netCDF4_8_netCDF4_6VLType_dtype, __pyx_setprop_7netCDF4_8_netCDF4_6VLType_dtype, 0, 0},
- {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_6VLType_name, __pyx_setprop_7netCDF4_8_netCDF4_6VLType_name, 0, 0},
+ {(char *)"_nc_type", __pyx_getprop_7netCDF4_8_netCDF4_6VLType__nc_type, __pyx_setprop_7netCDF4_8_netCDF4_6VLType__nc_type, (char *)0, 0},
+ {(char *)"dtype", __pyx_getprop_7netCDF4_8_netCDF4_6VLType_dtype, __pyx_setprop_7netCDF4_8_netCDF4_6VLType_dtype, (char *)0, 0},
+ {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_6VLType_name, __pyx_setprop_7netCDF4_8_netCDF4_6VLType_name, (char *)0, 0},
{0, 0, 0, 0, 0}
};
@@ -73611,10 +72843,10 @@ static PyMethodDef __pyx_methods_7netCDF4_8_netCDF4_EnumType[] = {
};
static struct PyGetSetDef __pyx_getsets_7netCDF4_8_netCDF4_EnumType[] = {
- {(char *)"_nc_type", __pyx_getprop_7netCDF4_8_netCDF4_8EnumType__nc_type, __pyx_setprop_7netCDF4_8_netCDF4_8EnumType__nc_type, 0, 0},
- {(char *)"dtype", __pyx_getprop_7netCDF4_8_netCDF4_8EnumType_dtype, __pyx_setprop_7netCDF4_8_netCDF4_8EnumType_dtype, 0, 0},
- {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_8EnumType_name, __pyx_setprop_7netCDF4_8_netCDF4_8EnumType_name, 0, 0},
- {(char *)"enum_dict", __pyx_getprop_7netCDF4_8_netCDF4_8EnumType_enum_dict, __pyx_setprop_7netCDF4_8_netCDF4_8EnumType_enum_dict, 0, 0},
+ {(char *)"_nc_type", __pyx_getprop_7netCDF4_8_netCDF4_8EnumType__nc_type, __pyx_setprop_7netCDF4_8_netCDF4_8EnumType__nc_type, (char *)0, 0},
+ {(char *)"dtype", __pyx_getprop_7netCDF4_8_netCDF4_8EnumType_dtype, __pyx_setprop_7netCDF4_8_netCDF4_8EnumType_dtype, (char *)0, 0},
+ {(char *)"name", __pyx_getprop_7netCDF4_8_netCDF4_8EnumType_name, __pyx_setprop_7netCDF4_8_netCDF4_8EnumType_name, (char *)0, 0},
+ {(char *)"enum_dict", __pyx_getprop_7netCDF4_8_netCDF4_8EnumType_enum_dict, __pyx_setprop_7netCDF4_8_netCDF4_8EnumType_enum_dict, (char *)0, 0},
{0, 0, 0, 0, 0}
};
@@ -73799,7 +73031,7 @@ static struct PyModuleDef __pyx_moduledef = {
PyModuleDef_HEAD_INIT,
#endif
"_netCDF4",
- __pyx_k_Version_1_2_3_Introduction_netc, /* m_doc */
+ __pyx_k_Version_1_2_4_Introduction_netc, /* m_doc */
-1, /* m_size */
__pyx_methods /* m_methods */,
NULL, /* m_reload */
@@ -73813,9 +73045,11 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0},
{&__pyx_kp_s_0m, __pyx_k_0m, sizeof(__pyx_k_0m), 0, 0, 1, 0},
{&__pyx_kp_s_1, __pyx_k_1, sizeof(__pyx_k_1), 0, 0, 1, 0},
- {&__pyx_kp_s_1_2_3, __pyx_k_1_2_3, sizeof(__pyx_k_1_2_3), 0, 0, 1, 0},
+ {&__pyx_kp_s_1_10, __pyx_k_1_10, sizeof(__pyx_k_1_10), 0, 0, 1, 0},
+ {&__pyx_kp_s_1_2_4, __pyx_k_1_2_4, sizeof(__pyx_k_1_2_4), 0, 0, 1, 0},
{&__pyx_kp_s_4_2_1, __pyx_k_4_2_1, sizeof(__pyx_k_4_2_1), 0, 0, 1, 0},
{&__pyx_kp_s_4_4_0, __pyx_k_4_4_0, sizeof(__pyx_k_4_4_0), 0, 0, 1, 0},
+ {&__pyx_kp_s_4_4_1, __pyx_k_4_4_1, sizeof(__pyx_k_4_4_1), 0, 0, 1, 0},
{&__pyx_kp_s_4m, __pyx_k_4m, sizeof(__pyx_k_4m), 0, 0, 1, 0},
{&__pyx_kp_s_A_numpy_dtype_object_describing, __pyx_k_A_numpy_dtype_object_describing, sizeof(__pyx_k_A_numpy_dtype_object_describing), 0, 0, 1, 0},
{&__pyx_kp_s_A_numpy_dtype_object_describing_2, __pyx_k_A_numpy_dtype_object_describing_2, sizeof(__pyx_k_A_numpy_dtype_object_describing_2), 0, 0, 1, 0},
@@ -73860,7 +73094,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_n_s_FillValue, __pyx_k_FillValue, sizeof(__pyx_k_FillValue), 0, 0, 1, 1},
{&__pyx_kp_s_FillValue_attribute_must_be_set, __pyx_k_FillValue_attribute_must_be_set, sizeof(__pyx_k_FillValue_attribute_must_be_set), 0, 0, 1, 0},
{&__pyx_kp_s_Group_name, __pyx_k_Group_name, sizeof(__pyx_k_Group_name), 0, 0, 1, 0},
- {&__pyx_n_s_HDF4, __pyx_k_HDF4, sizeof(__pyx_k_HDF4), 0, 0, 1, 1},
{&__pyx_n_s_IOError, __pyx_k_IOError, sizeof(__pyx_k_IOError), 0, 0, 1, 1},
{&__pyx_kp_s_If_True_child_Dimension_and_Vari, __pyx_k_If_True_child_Dimension_and_Vari, sizeof(__pyx_k_If_True_child_Dimension_and_Vari), 0, 0, 1, 0},
{&__pyx_kp_s_If_True_data_is_automatically_co, __pyx_k_If_True_data_is_automatically_co, sizeof(__pyx_k_If_True_data_is_automatically_co), 0, 0, 1, 0},
@@ -73913,7 +73146,6 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_n_s_UnicodeDecodeError, __pyx_k_UnicodeDecodeError, sizeof(__pyx_k_UnicodeDecodeError), 0, 0, 1, 1},
{&__pyx_n_s_UnicodeError, __pyx_k_UnicodeError, sizeof(__pyx_k_UnicodeError), 0, 0, 1, 1},
{&__pyx_kp_s_Unsupported_compound_type_elemen, __pyx_k_Unsupported_compound_type_elemen, sizeof(__pyx_k_Unsupported_compound_type_elemen), 0, 0, 1, 0},
- {&__pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_k_Users_jwhitaker_python_netcdf4, sizeof(__pyx_k_Users_jwhitaker_python_netcdf4), 0, 0, 1, 0},
{&__pyx_n_s_V, __pyx_k_V, sizeof(__pyx_k_V), 0, 0, 1, 1},
{&__pyx_kp_s_VLType_dtype, __pyx_k_VLType_dtype, sizeof(__pyx_k_VLType_dtype), 0, 0, 1, 0},
{&__pyx_kp_s_VLType_name, __pyx_k_VLType_name, sizeof(__pyx_k_VLType_name), 0, 0, 1, 0},
@@ -73941,6 +73173,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_kp_s_Variable_shape, __pyx_k_Variable_shape, sizeof(__pyx_k_Variable_shape), 0, 0, 1, 0},
{&__pyx_kp_s_Variable_size, __pyx_k_Variable_size, sizeof(__pyx_k_Variable_size), 0, 0, 1, 0},
{&__pyx_n_s_Variable_typecode, __pyx_k_Variable_typecode, sizeof(__pyx_k_Variable_typecode), 0, 0, 1, 1},
+ {&__pyx_kp_s_WARNING_Backwards_incompatible, __pyx_k_WARNING_Backwards_incompatible, sizeof(__pyx_k_WARNING_Backwards_incompatible), 0, 0, 1, 0},
{&__pyx_kp_s_WARNING_unsupported_Compound_typ, __pyx_k_WARNING_unsupported_Compound_typ, sizeof(__pyx_k_WARNING_unsupported_Compound_typ), 0, 0, 1, 0},
{&__pyx_kp_s_WARNING_unsupported_Enum_type_sk, __pyx_k_WARNING_unsupported_Enum_type_sk, sizeof(__pyx_k_WARNING_unsupported_Enum_type_sk), 0, 0, 1, 0},
{&__pyx_kp_s_WARNING_unsupported_VLEN_type_sk, __pyx_k_WARNING_unsupported_VLEN_type_sk, sizeof(__pyx_k_WARNING_unsupported_VLEN_type_sk), 0, 0, 1, 0},
@@ -74280,7 +73513,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_n_s_num, __pyx_k_num, sizeof(__pyx_k_num), 0, 0, 1, 1},
{&__pyx_n_s_num2date, __pyx_k_num2date, sizeof(__pyx_k_num2date), 0, 0, 1, 1},
{&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
- {&__pyx_kp_s_numpy_data_type_for_primitive_da_2, __pyx_k_numpy_data_type_for_primitive_da_2, sizeof(__pyx_k_numpy_data_type_for_primitive_da_2), 0, 0, 1, 0},
+ {&__pyx_kp_s_numpy_data_type_for_primitive_da, __pyx_k_numpy_data_type_for_primitive_da, sizeof(__pyx_k_numpy_data_type_for_primitive_da), 0, 0, 1, 0},
{&__pyx_n_s_numv, __pyx_k_numv, sizeof(__pyx_k_numv), 0, 0, 1, 1},
{&__pyx_n_s_nunlimdim, __pyx_k_nunlimdim, sizeof(__pyx_k_nunlimdim), 0, 0, 1, 1},
{&__pyx_n_s_nv, __pyx_k_nv, sizeof(__pyx_k_nv), 0, 0, 1, 1},
@@ -74309,6 +73542,7 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{&__pyx_n_s_preemption, __pyx_k_preemption, sizeof(__pyx_k_preemption), 0, 0, 1, 1},
{&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1},
{&__pyx_n_s_private_atts, __pyx_k_private_atts, sizeof(__pyx_k_private_atts), 0, 0, 1, 1},
+ {&__pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_k_private_tmp_netcdf4_python_netC, sizeof(__pyx_k_private_tmp_netcdf4_python_netC), 0, 0, 1, 0},
{&__pyx_n_s_prod, __pyx_k_prod, sizeof(__pyx_k_prod), 0, 0, 1, 1},
{&__pyx_n_s_proleptic_gregorian, __pyx_k_proleptic_gregorian, sizeof(__pyx_k_proleptic_gregorian), 0, 0, 1, 1},
{&__pyx_n_s_proxy, __pyx_k_proxy, sizeof(__pyx_k_proxy), 0, 0, 1, 1},
@@ -74491,21 +73725,21 @@ static __Pyx_StringTabEntry __pyx_string_tab[] = {
{0, 0, 0, 0, 0, 0, 0}
};
static int __Pyx_InitCachedBuiltins(void) {
- __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 924; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1075; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1099; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1123; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1159; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_UnicodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeError); if (!__pyx_builtin_UnicodeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1247; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2300; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3922; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_n_s_sum); if (!__pyx_builtin_sum) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4259; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4274; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_builtin_UnicodeDecodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeDecodeError); if (!__pyx_builtin_UnicodeDecodeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4957; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(0, 927, __pyx_L1_error)
+ __pyx_builtin_object = __Pyx_GetBuiltinName(__pyx_n_s_object); if (!__pyx_builtin_object) __PYX_ERR(0, 5567, __pyx_L1_error)
+ __pyx_builtin_AttributeError = __Pyx_GetBuiltinName(__pyx_n_s_AttributeError); if (!__pyx_builtin_AttributeError) __PYX_ERR(0, 1088, __pyx_L1_error)
+ __pyx_builtin_KeyError = __Pyx_GetBuiltinName(__pyx_n_s_KeyError); if (!__pyx_builtin_KeyError) __PYX_ERR(0, 1136, __pyx_L1_error)
+ __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 1172, __pyx_L1_error)
+ __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(0, 1181, __pyx_L1_error)
+ __pyx_builtin_UnicodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeError); if (!__pyx_builtin_UnicodeError) __PYX_ERR(0, 1260, __pyx_L1_error)
+ __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 1274, __pyx_L1_error)
+ __pyx_builtin_IOError = __Pyx_GetBuiltinName(__pyx_n_s_IOError); if (!__pyx_builtin_IOError) __PYX_ERR(0, 1811, __pyx_L1_error)
+ __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(0, 1862, __pyx_L1_error)
+ __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 3683, __pyx_L1_error)
+ __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(0, 3925, __pyx_L1_error)
+ __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_n_s_sum); if (!__pyx_builtin_sum) __PYX_ERR(0, 4251, __pyx_L1_error)
+ __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 4266, __pyx_L1_error)
+ __pyx_builtin_UnicodeDecodeError = __Pyx_GetBuiltinName(__pyx_n_s_UnicodeDecodeError); if (!__pyx_builtin_UnicodeDecodeError) __PYX_ERR(0, 4957, __pyx_L1_error)
return 0;
__pyx_L1_error:;
return -1;
@@ -74515,803 +73749,726 @@ static int __Pyx_InitCachedConstants(void) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);
- /* "netCDF4/_netCDF4.pyx":1113
+ /* "netCDF4/_netCDF4.pyx":1126
* else:
* pstring =\
* value_arr.tostring().decode(default_encoding,unicode_error).replace('\x00','') # <<<<<<<<<<<<<<
* return pstring
* elif att_type == NC_STRING:
*/
- __pyx_tuple__3 = PyTuple_Pack(2, __pyx_kp_s_, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1113; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__3 = PyTuple_Pack(2, __pyx_kp_s_, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 1126, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__3);
__Pyx_GIVEREF(__pyx_tuple__3);
- /* "netCDF4/_netCDF4.pyx":1119
+ /* "netCDF4/_netCDF4.pyx":1132
* with nogil:
* ierr = nc_get_att_string(_grpid, varid, attname, &stratt)
* pstring = stratt.decode(default_encoding,unicode_error).replace('\x00','') # <<<<<<<<<<<<<<
* ierr = nc_free_string(1, &stratt) # free memory in netcdf C lib
* return pstring
*/
- __pyx_tuple__4 = PyTuple_Pack(2, __pyx_kp_s_, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1119; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__4 = PyTuple_Pack(2, __pyx_kp_s_, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 1132, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__4);
__Pyx_GIVEREF(__pyx_tuple__4);
- /* "netCDF4/_netCDF4.pyx":1123
+ /* "netCDF4/_netCDF4.pyx":1136
* return pstring
* else:
* raise KeyError('vlen string array attributes not supported') # <<<<<<<<<<<<<<
* else:
* # a regular numeric or compound type.
*/
- __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_vlen_string_array_attributes_not); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1123; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_vlen_string_array_attributes_not); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 1136, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__5);
__Pyx_GIVEREF(__pyx_tuple__5);
- /* "netCDF4/_netCDF4.pyx":1159
+ /* "netCDF4/_netCDF4.pyx":1172
* # Private function to set the netCDF file format
* if format not in _format_dict:
* raise ValueError("unrecognized format requested") # <<<<<<<<<<<<<<
* nc_set_default_format(_format_dict[format], NULL)
*
*/
- __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_unrecognized_format_requested); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1159; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_unrecognized_format_requested); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 1172, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__6);
__Pyx_GIVEREF(__pyx_tuple__6);
- /* "netCDF4/_netCDF4.pyx":1170
+ /* "netCDF4/_netCDF4.pyx":1183
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
* if formatp not in _reverse_format_dict:
* raise ValueError('format not supported by python interface') # <<<<<<<<<<<<<<
* return _reverse_format_dict[formatp]
*
*/
- __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_format_not_supported_by_python_i); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1170; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_format_not_supported_by_python_i); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 1183, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__7);
__Pyx_GIVEREF(__pyx_tuple__7);
- /* "netCDF4/_netCDF4.pyx":1214
+ /* "netCDF4/_netCDF4.pyx":1227
* # if 64-bit datatype not supported, cast to 32 bit integers.
* fmt = _get_format(grp._grpid)
* is_netcdf3 = fmt.startswith('NETCDF3') or fmt == 'NETCDF4_CLASSIC' # <<<<<<<<<<<<<<
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\
* is_netcdf3):
*/
- __pyx_tuple__8 = PyTuple_Pack(1, __pyx_n_s_NETCDF3); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1214; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__8 = PyTuple_Pack(1, __pyx_n_s_NETCDF3); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 1227, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__8);
__Pyx_GIVEREF(__pyx_tuple__8);
- /* "netCDF4/_netCDF4.pyx":1215
+ /* "netCDF4/_netCDF4.pyx":1228
* fmt = _get_format(grp._grpid)
* is_netcdf3 = fmt.startswith('NETCDF3') or fmt == 'NETCDF4_CLASSIC'
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\ # <<<<<<<<<<<<<<
* is_netcdf3):
* value_arr = value_arr.astype('i4')
*/
- __pyx_slice__9 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1215; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_slice__9 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__9)) __PYX_ERR(0, 1228, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__9);
__Pyx_GIVEREF(__pyx_slice__9);
- /* "netCDF4/_netCDF4.pyx":1217
+ /* "netCDF4/_netCDF4.pyx":1230
* if value_arr.dtype.str[1:] == 'i8' and ('i8' not in _supportedtypes or\
* is_netcdf3):
* value_arr = value_arr.astype('i4') # <<<<<<<<<<<<<<
* # if array contains ascii strings, write a text attribute (stored as bytes).
* # if array contains unicode strings, and data model is NETCDF4,
*/
- __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_s_i4); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1217; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__10 = PyTuple_Pack(1, __pyx_n_s_i4); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 1230, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__10);
__Pyx_GIVEREF(__pyx_tuple__10);
- /* "netCDF4/_netCDF4.pyx":1260
+ /* "netCDF4/_netCDF4.pyx":1273
* if value_arr.dtype.kind == 'V': # compound attribute.
* xtype = _find_cmptype(grp,value_arr.dtype)
* elif value_arr.dtype.str[1:] not in _supportedtypes: # <<<<<<<<<<<<<<
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:])
* elif xtype == -99: # if xtype is not passed in as kwarg.
*/
- __pyx_slice__11 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1260; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_slice__11 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__11)) __PYX_ERR(0, 1273, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__11);
__Pyx_GIVEREF(__pyx_slice__11);
- /* "netCDF4/_netCDF4.pyx":1261
+ /* "netCDF4/_netCDF4.pyx":1274
* xtype = _find_cmptype(grp,value_arr.dtype)
* elif value_arr.dtype.str[1:] not in _supportedtypes:
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:]) # <<<<<<<<<<<<<<
* elif xtype == -99: # if xtype is not passed in as kwarg.
* xtype = _nptonctype[value_arr.dtype.str[1:]]
*/
- __pyx_slice__12 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1261; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_slice__12 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__12)) __PYX_ERR(0, 1274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__12);
__Pyx_GIVEREF(__pyx_slice__12);
- /* "netCDF4/_netCDF4.pyx":1263
+ /* "netCDF4/_netCDF4.pyx":1276
* raise TypeError, 'illegal data type for attribute, must be one of %s, got %s' % (_supportedtypes, value_arr.dtype.str[1:])
* elif xtype == -99: # if xtype is not passed in as kwarg.
* xtype = _nptonctype[value_arr.dtype.str[1:]] # <<<<<<<<<<<<<<
* lenarr = PyArray_SIZE(value_arr)
* ierr = nc_put_att(grp._grpid, varid, attname, xtype, lenarr, value_arr.data)
*/
- __pyx_slice__13 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1263; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_slice__13 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__13)) __PYX_ERR(0, 1276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__13);
__Pyx_GIVEREF(__pyx_slice__13);
- /* "netCDF4/_netCDF4.pyx":1841
+ /* "netCDF4/_netCDF4.pyx":1851
* # last name in path, could be a variable or group
* dirname, lastname = posixpath.split(elem)
* nestedgroups = dirname.split('/') # <<<<<<<<<<<<<<
* group = self
* # iterate over groups in path.
*/
- __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s__16); if (unlikely(!__pyx_tuple__17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1841; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_s__16); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(0, 1851, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__17);
__Pyx_GIVEREF(__pyx_tuple__17);
- /* "netCDF4/_netCDF4.pyx":1899
+ /* "netCDF4/_netCDF4.pyx":1909
* [_tostr(self.variables[varname].dtype)+' \033[4m'+_tostr(varname)+'\033[0m'+
* (((_tostr(self.variables[varname].dimensions)
* .replace("u'",""))\ # <<<<<<<<<<<<<<
* .replace("'",""))\
* .replace(", ",","))\
*/
- __pyx_tuple__18 = PyTuple_Pack(2, __pyx_kp_s_u, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__18)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1899; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__18 = PyTuple_Pack(2, __pyx_kp_s_u, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(0, 1909, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__18);
__Pyx_GIVEREF(__pyx_tuple__18);
- /* "netCDF4/_netCDF4.pyx":1900
+ /* "netCDF4/_netCDF4.pyx":1910
* (((_tostr(self.variables[varname].dimensions)
* .replace("u'",""))\
* .replace("'",""))\ # <<<<<<<<<<<<<<
* .replace(", ",","))\
* .replace(",)",")") for varname in self.variables.keys()])
*/
- __pyx_tuple__20 = PyTuple_Pack(2, __pyx_kp_s__19, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__20)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1900; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__20 = PyTuple_Pack(2, __pyx_kp_s__19, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 1910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__20);
__Pyx_GIVEREF(__pyx_tuple__20);
- /* "netCDF4/_netCDF4.pyx":1901
+ /* "netCDF4/_netCDF4.pyx":1911
* .replace("u'",""))\
* .replace("'",""))\
* .replace(", ",","))\ # <<<<<<<<<<<<<<
* .replace(",)",")") for varname in self.variables.keys()])
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()])
*/
- __pyx_tuple__23 = PyTuple_Pack(2, __pyx_kp_s__21, __pyx_kp_s__22); if (unlikely(!__pyx_tuple__23)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1901; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__23 = PyTuple_Pack(2, __pyx_kp_s__21, __pyx_kp_s__22); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(0, 1911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__23);
__Pyx_GIVEREF(__pyx_tuple__23);
- /* "netCDF4/_netCDF4.pyx":1902
+ /* "netCDF4/_netCDF4.pyx":1912
* .replace("'",""))\
* .replace(", ",","))\
* .replace(",)",")") for varname in self.variables.keys()]) # <<<<<<<<<<<<<<
* grpnames = tuple([_tostr(grpname) for grpname in self.groups.keys()])
* if self.path == '/':
*/
- __pyx_tuple__26 = PyTuple_Pack(2, __pyx_kp_s__24, __pyx_kp_s__25); if (unlikely(!__pyx_tuple__26)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1902; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__26 = PyTuple_Pack(2, __pyx_kp_s__24, __pyx_kp_s__25); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 1912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__26);
__Pyx_GIVEREF(__pyx_tuple__26);
- /* "netCDF4/_netCDF4.pyx":2258
+ /* "netCDF4/_netCDF4.pyx":2268
* # if group specified as a path, split out group names
* groupname = posixpath.normpath(groupname)
* nestedgroups = groupname.split('/') # <<<<<<<<<<<<<<
* group = self
* # loop over group names, create parent groups if they do not already
*/
- __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s__16); if (unlikely(!__pyx_tuple__27)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2258; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s__16); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 2268, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__27);
__Pyx_GIVEREF(__pyx_tuple__27);
- /* "netCDF4/_netCDF4.pyx":2355
+ /* "netCDF4/_netCDF4.pyx":2365
* if name not in _private_atts:
* self.setncattr(name, value)
* elif not name.endswith('__'): # <<<<<<<<<<<<<<
* if hasattr(self,name):
* raise AttributeError(
*/
- __pyx_tuple__29 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__29)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2355; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__29 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 2365, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__29);
__Pyx_GIVEREF(__pyx_tuple__29);
- /* "netCDF4/_netCDF4.pyx":2365
+ /* "netCDF4/_netCDF4.pyx":2375
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<<
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__':
*/
- __pyx_tuple__30 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__30)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__30 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 2375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__30);
__Pyx_GIVEREF(__pyx_tuple__30);
- __pyx_tuple__31 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__31)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__31 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 2375, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__31);
__Pyx_GIVEREF(__pyx_tuple__31);
- /* "netCDF4/_netCDF4.pyx":2615
+ /* "netCDF4/_netCDF4.pyx":2625
* overrides `netCDF4.Dataset` close method which does not apply to `netCDF4.Group`
* instances, raises IOError."""
* raise IOError('cannot close a `netCDF4.Group` (only applies to Dataset)') # <<<<<<<<<<<<<<
*
* def _getname(self):
*/
- __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_cannot_close_a_netCDF4_Group_onl); if (unlikely(!__pyx_tuple__32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2615; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_cannot_close_a_netCDF4_Group_onl); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 2625, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__32);
__Pyx_GIVEREF(__pyx_tuple__32);
- /* "netCDF4/_netCDF4.pyx":2632
+ /* "netCDF4/_netCDF4.pyx":2642
* return self._getname()
* def __set__(self,value):
* raise AttributeError("name cannot be altered") # <<<<<<<<<<<<<<
*
*
*/
- __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_name_cannot_be_altered); if (unlikely(!__pyx_tuple__33)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_name_cannot_be_altered); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 2642, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__33);
__Pyx_GIVEREF(__pyx_tuple__33);
- /* "netCDF4/_netCDF4.pyx":2719
+ /* "netCDF4/_netCDF4.pyx":2729
* return self._getname()
* def __set__(self,value):
* raise AttributeError("name cannot be altered") # <<<<<<<<<<<<<<
*
* property size:
*/
- __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_name_cannot_be_altered); if (unlikely(!__pyx_tuple__34)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2719; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_name_cannot_be_altered); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 2729, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__34);
__Pyx_GIVEREF(__pyx_tuple__34);
- /* "netCDF4/_netCDF4.pyx":2726
+ /* "netCDF4/_netCDF4.pyx":2736
* return len(self)
* def __set__(self,value):
* raise AttributeError("size cannot be altered") # <<<<<<<<<<<<<<
*
* def __repr__(self):
*/
- __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_size_cannot_be_altered); if (unlikely(!__pyx_tuple__35)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2726; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_size_cannot_be_altered); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 2736, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__35);
__Pyx_GIVEREF(__pyx_tuple__35);
- /* "netCDF4/_netCDF4.pyx":3054
+ /* "netCDF4/_netCDF4.pyx":3064
* if datatype==str:
* if grp.data_model != 'NETCDF4':
* raise ValueError( # <<<<<<<<<<<<<<
* 'Variable length strings are only supported for the '
* 'NETCDF4 format. For other formats, consider using '
*/
- __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_Variable_length_strings_are_only); if (unlikely(!__pyx_tuple__38)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3054; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_Variable_length_strings_are_only); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 3064, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__38);
__Pyx_GIVEREF(__pyx_tuple__38);
- /* "netCDF4/_netCDF4.pyx":3064
+ /* "netCDF4/_netCDF4.pyx":3074
* # dtype variable attribute is a numpy datatype object.
* self.dtype = datatype.dtype
* elif datatype.str[1:] in _supportedtypes: # <<<<<<<<<<<<<<
* self._isprimitive = True
* # find netCDF primitive data type corresponding to
*/
- __pyx_slice__39 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__39)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3064; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_slice__39 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__39)) __PYX_ERR(0, 3074, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__39);
__Pyx_GIVEREF(__pyx_slice__39);
- /* "netCDF4/_netCDF4.pyx":3068
+ /* "netCDF4/_netCDF4.pyx":3078
* # find netCDF primitive data type corresponding to
* # specified numpy data type.
* xtype = _nptonctype[datatype.str[1:]] # <<<<<<<<<<<<<<
* # dtype variable attribute is a numpy datatype object.
* self.dtype = datatype
*/
- __pyx_slice__40 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__40)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3068; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_slice__40 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__40)) __PYX_ERR(0, 3078, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__40);
__Pyx_GIVEREF(__pyx_slice__40);
- /* "netCDF4/_netCDF4.pyx":3108
+ /* "netCDF4/_netCDF4.pyx":3118
* # of vars are created. This change only lasts as long as file is
* # open.
* if grp.data_model.startswith('NETCDF4') and chunk_cache is not None: # <<<<<<<<<<<<<<
* ierr = nc_get_var_chunk_cache(self._grpid, self._varid, &sizep,
* &nelemsp, &preemptionp)
*/
- __pyx_tuple__41 = PyTuple_Pack(1, __pyx_n_s_NETCDF4); if (unlikely(!__pyx_tuple__41)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3108; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__41 = PyTuple_Pack(1, __pyx_n_s_NETCDF4); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 3118, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__41);
__Pyx_GIVEREF(__pyx_tuple__41);
- /* "netCDF4/_netCDF4.pyx":3150
+ /* "netCDF4/_netCDF4.pyx":3160
* icontiguous = NC_CONTIGUOUS
* if chunksizes is not None:
* raise ValueError('cannot specify chunksizes for a contiguous dataset') # <<<<<<<<<<<<<<
* else:
* icontiguous = NC_CHUNKED
*/
- __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_cannot_specify_chunksizes_for_a); if (unlikely(!__pyx_tuple__42)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3150; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_cannot_specify_chunksizes_for_a); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 3160, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__42);
__Pyx_GIVEREF(__pyx_tuple__42);
- /* "netCDF4/_netCDF4.pyx":3158
+ /* "netCDF4/_netCDF4.pyx":3168
* if len(chunksizes) != len(dimensions):
* if grp.data_model != 'NETCDF4': grp._enddef()
* raise ValueError('chunksizes must be a sequence with the same length as dimensions') # <<<<<<<<<<<<<<
* chunksizesp = <size_t *>malloc(sizeof(size_t) * ndims)
* for n from 0 <= n < ndims:
*/
- __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_chunksizes_must_be_a_sequence_wi); if (unlikely(!__pyx_tuple__43)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3158; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_chunksizes_must_be_a_sequence_wi); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 3168, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__43);
__Pyx_GIVEREF(__pyx_tuple__43);
- /* "netCDF4/_netCDF4.pyx":3210
+ /* "netCDF4/_netCDF4.pyx":3220
* fillval, xtype=xtype)
* else:
* raise AttributeError("cannot set _FillValue attribute for VLEN or compound variable") # <<<<<<<<<<<<<<
* if least_significant_digit is not None:
* self.least_significant_digit = least_significant_digit
*/
- __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_cannot_set__FillValue_attribute); if (unlikely(!__pyx_tuple__44)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3210; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_cannot_set__FillValue_attribute); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 3220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__44);
__Pyx_GIVEREF(__pyx_tuple__44);
- /* "netCDF4/_netCDF4.pyx":3292
+ /* "netCDF4/_netCDF4.pyx":3302
* msg = 'filling on'
* except AttributeError:
* fillval = default_fillvals[self.dtype.str[1:]] # <<<<<<<<<<<<<<
* if self.dtype.str[1:] in ['u1','i1']:
* msg = 'filling on, default _FillValue of %s ignored\n' % fillval
*/
- __pyx_slice__45 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__45)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3292; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_slice__45 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__45)) __PYX_ERR(0, 3302, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__45);
__Pyx_GIVEREF(__pyx_slice__45);
- /* "netCDF4/_netCDF4.pyx":3293
+ /* "netCDF4/_netCDF4.pyx":3303
* except AttributeError:
* fillval = default_fillvals[self.dtype.str[1:]]
* if self.dtype.str[1:] in ['u1','i1']: # <<<<<<<<<<<<<<
* msg = 'filling on, default _FillValue of %s ignored\n' % fillval
* else:
*/
- __pyx_slice__46 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__46)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3293; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_slice__46 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__46)) __PYX_ERR(0, 3303, __pyx_L1_error)
__Pyx_GOTREF(__pyx_slice__46);
__Pyx_GIVEREF(__pyx_slice__46);
- /* "netCDF4/_netCDF4.pyx":3348
+ /* "netCDF4/_netCDF4.pyx":3358
* return self._getname()
* def __set__(self,value):
* raise AttributeError("name cannot be altered") # <<<<<<<<<<<<<<
*
* property datatype:
*/
- __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_s_name_cannot_be_altered); if (unlikely(!__pyx_tuple__47)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3348; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__47 = PyTuple_Pack(1, __pyx_kp_s_name_cannot_be_altered); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 3358, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__47);
__Pyx_GIVEREF(__pyx_tuple__47);
- /* "netCDF4/_netCDF4.pyx":3374
+ /* "netCDF4/_netCDF4.pyx":3384
* return shape
* def __set__(self,value):
* raise AttributeError("shape cannot be altered") # <<<<<<<<<<<<<<
*
* property size:
*/
- __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_s_shape_cannot_be_altered); if (unlikely(!__pyx_tuple__48)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3374; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_s_shape_cannot_be_altered); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 3384, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__48);
__Pyx_GIVEREF(__pyx_tuple__48);
- /* "netCDF4/_netCDF4.pyx":3386
+ /* "netCDF4/_netCDF4.pyx":3396
* return self._getdims()
* def __set__(self,value):
* raise AttributeError("dimensions cannot be altered") # <<<<<<<<<<<<<<
*
*
*/
- __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_s_dimensions_cannot_be_altered); if (unlikely(!__pyx_tuple__49)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3386; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_s_dimensions_cannot_be_altered); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 3396, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__49);
__Pyx_GIVEREF(__pyx_tuple__49);
- /* "netCDF4/_netCDF4.pyx":3610
- * value = numpy.array(value, self.dtype)
+ /* "netCDF4/_netCDF4.pyx":3620
+ * if (is_native_little and self.endian() == 'big') or\
+ * (is_native_big and self.endian() == 'little'):
+ * value = numpy.array(value, self.dtype).byteswap(True) # <<<<<<<<<<<<<<
+ * else:
+ * value = numpy.array(value, self.dtype)
+ */
+ __pyx_tuple__50 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 3620, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__50);
+ __Pyx_GIVEREF(__pyx_tuple__50);
+
+ /* "netCDF4/_netCDF4.pyx":3624
+ * value = numpy.array(value, self.dtype)
* self.setncattr(name, value)
* elif not name.endswith('__'): # <<<<<<<<<<<<<<
* if hasattr(self,name):
* raise AttributeError(
*/
- __pyx_tuple__50 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__50)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3610; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__50);
- __Pyx_GIVEREF(__pyx_tuple__50);
+ __pyx_tuple__51 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 3624, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__51);
+ __Pyx_GIVEREF(__pyx_tuple__51);
- /* "netCDF4/_netCDF4.pyx":3620
+ /* "netCDF4/_netCDF4.pyx":3634
* # if name in _private_atts, it is stored at the python
* # level and not in the netCDF file.
* if name.startswith('__') and name.endswith('__'): # <<<<<<<<<<<<<<
* # if __dict__ requested, return a dict with netCDF attributes.
* if name == '__dict__':
*/
- __pyx_tuple__51 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__51)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__51);
- __Pyx_GIVEREF(__pyx_tuple__51);
- __pyx_tuple__52 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__52)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3620; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__52 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 3634, __pyx_L1_error)
__Pyx_GOTREF(__pyx_tuple__52);
__Pyx_GIVEREF(__pyx_tuple__52);
+ __pyx_tuple__53 = PyTuple_Pack(1, __pyx_n_s__28); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(0, 3634, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__53);
+ __Pyx_GIVEREF(__pyx_tuple__53);
- /* "netCDF4/_netCDF4.pyx":3668
+ /* "netCDF4/_netCDF4.pyx":3682
* # The convention used is that for those cases,
* # put_ind for this dimension is set to -1 by _StartCountStride.
* squeeze = data.ndim * [slice(None),] # <<<<<<<<<<<<<<
* for i,n in enumerate(put_ind.shape[:-1]):
* if n == 1 and put_ind[...,i].ravel()[0] == -1:
*/
- __pyx_slice__53 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__53)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3668; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__53);
- __Pyx_GIVEREF(__pyx_slice__53);
+ __pyx_slice__54 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__54)) __PYX_ERR(0, 3682, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__54);
+ __Pyx_GIVEREF(__pyx_slice__54);
- /* "netCDF4/_netCDF4.pyx":3669
+ /* "netCDF4/_netCDF4.pyx":3683
* # put_ind for this dimension is set to -1 by _StartCountStride.
* squeeze = data.ndim * [slice(None),]
* for i,n in enumerate(put_ind.shape[:-1]): # <<<<<<<<<<<<<<
* if n == 1 and put_ind[...,i].ravel()[0] == -1:
* squeeze[i] = 0
*/
- __pyx_slice__54 = PySlice_New(Py_None, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_slice__54)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__54);
- __Pyx_GIVEREF(__pyx_slice__54);
-
- /* "netCDF4/_netCDF4.pyx":3742
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big):
- * mval.byteswap(True) # <<<<<<<<<<<<<<
- * if mval.shape == (): # mval a scalar.
- * hasmval = data==mval
- */
- __pyx_tuple__55 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__55)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3742; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__55);
- __Pyx_GIVEREF(__pyx_tuple__55);
+ __pyx_slice__55 = PySlice_New(Py_None, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_slice__55)) __PYX_ERR(0, 3683, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__55);
+ __Pyx_GIVEREF(__pyx_slice__55);
- /* "netCDF4/_netCDF4.pyx":3770
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big):
- * fval.byteswap(True) # <<<<<<<<<<<<<<
- * # is _FillValue a NaN?
- * try:
- */
- __pyx_tuple__56 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__56)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3770; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__56);
- __Pyx_GIVEREF(__pyx_tuple__56);
-
- /* "netCDF4/_netCDF4.pyx":3805
+ /* "netCDF4/_netCDF4.pyx":3813
* # small to assume one of the values should appear as a missing
* # value unless a _FillValue attribute is set explicitly."
* if no_fill != 1 and self.dtype.str[1:] not in ['u1','i1']: # <<<<<<<<<<<<<<
* fillval = numpy.array(default_fillvals[self.dtype.str[1:]],self.dtype)
- * # byte swap the _FillValue if endian-ness of the variable
+ * has_fillval = data == fillval
*/
- __pyx_slice__57 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__57)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__57);
- __Pyx_GIVEREF(__pyx_slice__57);
+ __pyx_slice__56 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__56)) __PYX_ERR(0, 3813, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__56);
+ __Pyx_GIVEREF(__pyx_slice__56);
- /* "netCDF4/_netCDF4.pyx":3806
+ /* "netCDF4/_netCDF4.pyx":3814
* # value unless a _FillValue attribute is set explicitly."
* if no_fill != 1 and self.dtype.str[1:] not in ['u1','i1']:
* fillval = numpy.array(default_fillvals[self.dtype.str[1:]],self.dtype) # <<<<<<<<<<<<<<
- * # byte swap the _FillValue if endian-ness of the variable
- * # is not native.
- */
- __pyx_slice__58 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__58)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3806; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__58);
- __Pyx_GIVEREF(__pyx_slice__58);
-
- /* "netCDF4/_netCDF4.pyx":3811
- * if (self.endian() == 'big' and is_native_little) or\
- * (self.endian() == 'little' and is_native_big):
- * fillval.byteswap(True) # <<<<<<<<<<<<<<
* has_fillval = data == fillval
* # if data is an array scalar, has_fillval will be a boolean.
*/
- __pyx_tuple__59 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__59)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3811; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__59);
- __Pyx_GIVEREF(__pyx_tuple__59);
+ __pyx_slice__57 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__57)) __PYX_ERR(0, 3814, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__57);
+ __Pyx_GIVEREF(__pyx_slice__57);
- /* "netCDF4/_netCDF4.pyx":3842
+ /* "netCDF4/_netCDF4.pyx":3845
* cdef ndarray data2
* if not self._isvlen:
* raise TypeError('_assign_vlen method only for use with VLEN variables') # <<<<<<<<<<<<<<
* ndims = self.ndim
* msg="data can only be assigned to VLEN variables using integer indices"
*/
- __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_s_assign_vlen_method_only_for_use); if (unlikely(!__pyx_tuple__60)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3842; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__60);
- __Pyx_GIVEREF(__pyx_tuple__60);
+ __pyx_tuple__58 = PyTuple_Pack(1, __pyx_kp_s_assign_vlen_method_only_for_use); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 3845, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__58);
+ __Pyx_GIVEREF(__pyx_tuple__58);
- /* "netCDF4/_netCDF4.pyx":3854
+ /* "netCDF4/_netCDF4.pyx":3857
* elem = self.shape[0]+elem
* else:
* raise IndexError("Illegal index") # <<<<<<<<<<<<<<
* elif isinstance(elem, tuple):
* if len(elem) != ndims:
*/
- __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_s_Illegal_index); if (unlikely(!__pyx_tuple__61)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3854; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__61);
- __Pyx_GIVEREF(__pyx_tuple__61);
+ __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_s_Illegal_index); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 3857, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__59);
+ __Pyx_GIVEREF(__pyx_tuple__59);
- /* "netCDF4/_netCDF4.pyx":3857
+ /* "netCDF4/_netCDF4.pyx":3860
* elif isinstance(elem, tuple):
* if len(elem) != ndims:
* raise IndexError("Illegal index") # <<<<<<<<<<<<<<
* elemnew = []
* for n,e in enumerate(elem):
*/
- __pyx_tuple__62 = PyTuple_Pack(1, __pyx_kp_s_Illegal_index); if (unlikely(!__pyx_tuple__62)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3857; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__62);
- __Pyx_GIVEREF(__pyx_tuple__62);
+ __pyx_tuple__60 = PyTuple_Pack(1, __pyx_kp_s_Illegal_index); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 3860, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__60);
+ __Pyx_GIVEREF(__pyx_tuple__60);
- /* "netCDF4/_netCDF4.pyx":3865
+ /* "netCDF4/_netCDF4.pyx":3868
* enew = self.shape[n]+e
* if enew < 0:
* raise IndexError("Illegal index") # <<<<<<<<<<<<<<
* else:
* elemnew.append(self.shape[n]+e)
*/
- __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_s_Illegal_index); if (unlikely(!__pyx_tuple__63)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 3865; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__63);
- __Pyx_GIVEREF(__pyx_tuple__63);
+ __pyx_tuple__61 = PyTuple_Pack(1, __pyx_kp_s_Illegal_index); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 3868, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__61);
+ __Pyx_GIVEREF(__pyx_tuple__61);
- /* "netCDF4/_netCDF4.pyx":4037
+ /* "netCDF4/_netCDF4.pyx":4040
* fillval = self._FillValue
* else:
* fillval = default_fillvals[self.dtype.str[1:]] # <<<<<<<<<<<<<<
* data = data.filled(fill_value=fillval)
*
*/
- __pyx_slice__64 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__64)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__64);
- __Pyx_GIVEREF(__pyx_slice__64);
+ __pyx_slice__62 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__62)) __PYX_ERR(0, 4040, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__62);
+ __Pyx_GIVEREF(__pyx_slice__62);
- /* "netCDF4/_netCDF4.pyx":4055
+ /* "netCDF4/_netCDF4.pyx":4058
* def __len__(self):
* if not self.shape:
* raise TypeError('len() of unsized object') # <<<<<<<<<<<<<<
* else:
* return self.shape[0]
*/
- __pyx_tuple__65 = PyTuple_Pack(1, __pyx_kp_s_len_of_unsized_object); if (unlikely(!__pyx_tuple__65)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__65);
- __Pyx_GIVEREF(__pyx_tuple__65);
+ __pyx_tuple__63 = PyTuple_Pack(1, __pyx_kp_s_len_of_unsized_object); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(0, 4058, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__63);
+ __Pyx_GIVEREF(__pyx_tuple__63);
- /* "netCDF4/_netCDF4.pyx":4067
+ /* "netCDF4/_netCDF4.pyx":4070
* Scientific.IO.NetCDF, can also be done by assigning to an Ellipsis slice ([...])."""
* if len(self.dimensions):
* raise IndexError('to assign values to a non-scalar variable, use a slice') # <<<<<<<<<<<<<<
* self[:]=val
*
*/
- __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_s_to_assign_values_to_a_non_scalar); if (unlikely(!__pyx_tuple__66)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4067; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__66);
- __Pyx_GIVEREF(__pyx_tuple__66);
+ __pyx_tuple__64 = PyTuple_Pack(1, __pyx_kp_s_to_assign_values_to_a_non_scalar); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 4070, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__64);
+ __Pyx_GIVEREF(__pyx_tuple__64);
- /* "netCDF4/_netCDF4.pyx":4068
+ /* "netCDF4/_netCDF4.pyx":4071
* if len(self.dimensions):
* raise IndexError('to assign values to a non-scalar variable, use a slice')
* self[:]=val # <<<<<<<<<<<<<<
*
* def getValue(self):
*/
- __pyx_slice__67 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__67)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4068; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__67);
- __Pyx_GIVEREF(__pyx_slice__67);
+ __pyx_slice__65 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__65)) __PYX_ERR(0, 4071, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__65);
+ __Pyx_GIVEREF(__pyx_slice__65);
- /* "netCDF4/_netCDF4.pyx":4077
+ /* "netCDF4/_netCDF4.pyx":4080
* Scientific.IO.NetCDF, can also be done by slicing with an Ellipsis ([...])."""
* if len(self.dimensions):
* raise IndexError('to retrieve values from a non-scalar variable, use slicing') # <<<<<<<<<<<<<<
* return self[slice(None)]
*
*/
- __pyx_tuple__68 = PyTuple_Pack(1, __pyx_kp_s_to_retrieve_values_from_a_non_sc); if (unlikely(!__pyx_tuple__68)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4077; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__68);
- __Pyx_GIVEREF(__pyx_tuple__68);
+ __pyx_tuple__66 = PyTuple_Pack(1, __pyx_kp_s_to_retrieve_values_from_a_non_sc); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 4080, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__66);
+ __Pyx_GIVEREF(__pyx_tuple__66);
- /* "netCDF4/_netCDF4.pyx":4078
+ /* "netCDF4/_netCDF4.pyx":4081
* if len(self.dimensions):
* raise IndexError('to retrieve values from a non-scalar variable, use slicing')
* return self[slice(None)] # <<<<<<<<<<<<<<
*
* def set_auto_maskandscale(self,maskandscale):
*/
- __pyx_slice__69 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__69)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4078; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__69);
- __Pyx_GIVEREF(__pyx_slice__69);
+ __pyx_slice__67 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__67)) __PYX_ERR(0, 4081, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__67);
+ __Pyx_GIVEREF(__pyx_slice__67);
- /* "netCDF4/_netCDF4.pyx":4221
+ /* "netCDF4/_netCDF4.pyx":4224
* startp[n] = start[n]+stride[n]*(count[n]-1)
* stride[n] = -stride[n]
* sl.append(slice(None, None, -1)) # this slice will reverse the data # <<<<<<<<<<<<<<
* else:
* startp[n] = start[n]
*/
- __pyx_slice__70 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__70)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4221; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__70);
- __Pyx_GIVEREF(__pyx_slice__70);
+ __pyx_slice__68 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__68)) __PYX_ERR(0, 4224, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__68);
+ __Pyx_GIVEREF(__pyx_slice__68);
- /* "netCDF4/_netCDF4.pyx":4225
+ /* "netCDF4/_netCDF4.pyx":4228
* startp[n] = start[n]
* stridep[n] = stride[n]
* sl.append(slice(None,None, 1)) # <<<<<<<<<<<<<<
* totelem = totelem*countp[n]
* # check to see that size of data array is what is expected
*/
- __pyx_slice__71 = PySlice_New(Py_None, Py_None, __pyx_int_1); if (unlikely(!__pyx_slice__71)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4225; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__71);
- __Pyx_GIVEREF(__pyx_slice__71);
+ __pyx_slice__69 = PySlice_New(Py_None, Py_None, __pyx_int_1); if (unlikely(!__pyx_slice__69)) __PYX_ERR(0, 4228, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__69);
+ __Pyx_GIVEREF(__pyx_slice__69);
- /* "netCDF4/_netCDF4.pyx":4231
+ /* "netCDF4/_netCDF4.pyx":4234
* dataelem = PyArray_SIZE(data)
* if totelem != dataelem:
* raise IndexError('size of data array does not conform to slice') # <<<<<<<<<<<<<<
* if negstride:
* # reverse data along axes with negative strides.
*/
- __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_s_size_of_data_array_does_not_conf); if (unlikely(!__pyx_tuple__72)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4231; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__72);
- __Pyx_GIVEREF(__pyx_tuple__72);
+ __pyx_tuple__70 = PyTuple_Pack(1, __pyx_kp_s_size_of_data_array_does_not_conf); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 4234, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__70);
+ __Pyx_GIVEREF(__pyx_tuple__70);
- /* "netCDF4/_netCDF4.pyx":4245
- * if self.endian() == 'native':
- * if is_native_little and data.dtype.byteorder == '>':
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if is_native_big and data.dtype.byteorder == '<':
- * data.byteswap(True)
- */
- __pyx_tuple__73 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__73)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4245; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__73);
- __Pyx_GIVEREF(__pyx_tuple__73);
-
- /* "netCDF4/_netCDF4.pyx":4247
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '<':
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if self.endian() == 'big':
- * if is_native_big and data.dtype.byteorder not in ['=','|']:
- */
- __pyx_tuple__74 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__74)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4247; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__74);
- __Pyx_GIVEREF(__pyx_tuple__74);
-
- /* "netCDF4/_netCDF4.pyx":4250
- * if self.endian() == 'big':
- * if is_native_big and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if is_native_little and data.dtype.byteorder == '=':
- * data.byteswap(True)
- */
- __pyx_tuple__75 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__75)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4250; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__75);
- __Pyx_GIVEREF(__pyx_tuple__75);
-
- /* "netCDF4/_netCDF4.pyx":4252
- * data.byteswap(True)
- * if is_native_little and data.dtype.byteorder == '=':
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if self.endian() == 'little':
- * if is_native_little and data.dtype.byteorder not in ['=','|']:
- */
- __pyx_tuple__76 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__76)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4252; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__76);
- __Pyx_GIVEREF(__pyx_tuple__76);
-
- /* "netCDF4/_netCDF4.pyx":4255
- * if self.endian() == 'little':
- * if is_native_little and data.dtype.byteorder not in ['=','|']:
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * if is_native_big and data.dtype.byteorder == '=':
- * data.byteswap(True)
- */
- __pyx_tuple__77 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__77)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4255; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__77);
- __Pyx_GIVEREF(__pyx_tuple__77);
-
- /* "netCDF4/_netCDF4.pyx":4257
- * data.byteswap(True)
- * if is_native_big and data.dtype.byteorder == '=':
- * data.byteswap(True) # <<<<<<<<<<<<<<
- * # strides all 1 or scalar variable, use put_vara (faster)
- * if sum(stride) == ndims or ndims == 0:
- */
- __pyx_tuple__78 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__78)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4257; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__78);
- __Pyx_GIVEREF(__pyx_tuple__78);
-
- /* "netCDF4/_netCDF4.pyx":4269
+ /* "netCDF4/_netCDF4.pyx":4261
* elif self._isvlen:
* if data.dtype.char !='O':
* raise TypeError('data to put in string variable must be an object array containing Python strings') # <<<<<<<<<<<<<<
* # flatten data array.
* data = data.flatten()
*/
- __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_s_data_to_put_in_string_variable_m); if (unlikely(!__pyx_tuple__79)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4269; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__79);
- __Pyx_GIVEREF(__pyx_tuple__79);
+ __pyx_tuple__71 = PyTuple_Pack(1, __pyx_kp_s_data_to_put_in_string_variable_m); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(0, 4261, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__71);
+ __Pyx_GIVEREF(__pyx_tuple__71);
- /* "netCDF4/_netCDF4.pyx":4288
+ /* "netCDF4/_netCDF4.pyx":4280
* startp, countp, strdata)
* else:
* raise IndexError('strides must all be 1 for string variables') # <<<<<<<<<<<<<<
* #ierr = nc_put_vars(self._grpid, self._varid,
* # startp, countp, stridep, strdata)
*/
- __pyx_tuple__80 = PyTuple_Pack(1, __pyx_kp_s_strides_must_all_be_1_for_string); if (unlikely(!__pyx_tuple__80)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4288; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__80);
- __Pyx_GIVEREF(__pyx_tuple__80);
+ __pyx_tuple__72 = PyTuple_Pack(1, __pyx_kp_s_strides_must_all_be_1_for_string); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 4280, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__72);
+ __Pyx_GIVEREF(__pyx_tuple__72);
- /* "netCDF4/_netCDF4.pyx":4304
+ /* "netCDF4/_netCDF4.pyx":4296
* elptr = (<void**>databuff)[0]
* dataarr = <ndarray>elptr
* if self.dtype != dataarr.dtype.str[1:]: # <<<<<<<<<<<<<<
* #dataarr = dataarr.astype(self.dtype) # cast data, if necessary.
* # casting doesn't work ?? just raise TypeError
*/
- __pyx_slice__81 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__81)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4304; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__81);
- __Pyx_GIVEREF(__pyx_slice__81);
+ __pyx_slice__73 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__73)) __PYX_ERR(0, 4296, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__73);
+ __Pyx_GIVEREF(__pyx_slice__73);
- /* "netCDF4/_netCDF4.pyx":4316
+ /* "netCDF4/_netCDF4.pyx":4308
* startp, countp, vldata)
* else:
* raise IndexError('strides must all be 1 for vlen variables') # <<<<<<<<<<<<<<
* #ierr = nc_put_vars(self._grpid, self._varid,
* # startp, countp, stridep, vldata)
*/
- __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_s_strides_must_all_be_1_for_vlen_v); if (unlikely(!__pyx_tuple__82)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4316; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__82);
- __Pyx_GIVEREF(__pyx_tuple__82);
+ __pyx_tuple__74 = PyTuple_Pack(1, __pyx_kp_s_strides_must_all_be_1_for_vlen_v); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 4308, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__74);
+ __Pyx_GIVEREF(__pyx_tuple__74);
- /* "netCDF4/_netCDF4.pyx":4344
+ /* "netCDF4/_netCDF4.pyx":4336
* for lendim in count:
* if lendim == -1:
* shapeout = shapeout + (1,) # <<<<<<<<<<<<<<
* squeeze_out = True
* else:
*/
- __pyx_tuple__83 = PyTuple_Pack(1, __pyx_int_1); if (unlikely(!__pyx_tuple__83)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4344; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__83);
- __Pyx_GIVEREF(__pyx_tuple__83);
+ __pyx_tuple__75 = PyTuple_Pack(1, __pyx_int_1); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(0, 4336, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__75);
+ __Pyx_GIVEREF(__pyx_tuple__75);
- /* "netCDF4/_netCDF4.pyx":4365
+ /* "netCDF4/_netCDF4.pyx":4357
* startp[n] = start[n]+stride[n]*(count[n]-1)
* stride[n] = -stride[n]
* sl.append(slice(None, None, -1)) # this slice will reverse the data # <<<<<<<<<<<<<<
* else:
* startp[n] = start[n]
*/
- __pyx_slice__84 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__84)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4365; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__84);
- __Pyx_GIVEREF(__pyx_slice__84);
+ __pyx_slice__76 = PySlice_New(Py_None, Py_None, __pyx_int_neg_1); if (unlikely(!__pyx_slice__76)) __PYX_ERR(0, 4357, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__76);
+ __Pyx_GIVEREF(__pyx_slice__76);
- /* "netCDF4/_netCDF4.pyx":4369
+ /* "netCDF4/_netCDF4.pyx":4361
* startp[n] = start[n]
* stridep[n] = stride[n]
* sl.append(slice(None,None, 1)) # <<<<<<<<<<<<<<
* if self._isprimitive or self._iscompound or self._isenum:
* data = numpy.empty(shapeout, self.dtype)
*/
- __pyx_slice__85 = PySlice_New(Py_None, Py_None, __pyx_int_1); if (unlikely(!__pyx_slice__85)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4369; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__85);
- __Pyx_GIVEREF(__pyx_slice__85);
+ __pyx_slice__77 = PySlice_New(Py_None, Py_None, __pyx_int_1); if (unlikely(!__pyx_slice__77)) __PYX_ERR(0, 4361, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__77);
+ __Pyx_GIVEREF(__pyx_slice__77);
- /* "netCDF4/_netCDF4.pyx":4402
+ /* "netCDF4/_netCDF4.pyx":4394
* else:
* # FIXME: is this a bug in netCDF4?
* raise IndexError('strides must all be 1 for string variables') # <<<<<<<<<<<<<<
* #ierr = nc_get_vars(self._grpid, self._varid,
* # startp, countp, stridep, strdata)
*/
- __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_s_strides_must_all_be_1_for_string); if (unlikely(!__pyx_tuple__86)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4402; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__86);
- __Pyx_GIVEREF(__pyx_tuple__86);
+ __pyx_tuple__78 = PyTuple_Pack(1, __pyx_kp_s_strides_must_all_be_1_for_string); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 4394, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__78);
+ __Pyx_GIVEREF(__pyx_tuple__78);
- /* "netCDF4/_netCDF4.pyx":4429
+ /* "netCDF4/_netCDF4.pyx":4421
* startp, countp, vldata)
* else:
* raise IndexError('strides must all be 1 for vlen variables') # <<<<<<<<<<<<<<
* #ierr = nc_get_vars(self._grpid, self._varid,
* # startp, countp, stridep, vldata)
*/
- __pyx_tuple__87 = PyTuple_Pack(1, __pyx_kp_s_strides_must_all_be_1_for_vlen_v); if (unlikely(!__pyx_tuple__87)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4429; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__87);
- __Pyx_GIVEREF(__pyx_tuple__87);
+ __pyx_tuple__79 = PyTuple_Pack(1, __pyx_kp_s_strides_must_all_be_1_for_vlen_v); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(0, 4421, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__79);
+ __Pyx_GIVEREF(__pyx_tuple__79);
+
+ /* "netCDF4/_netCDF4.pyx":4455
+ * if (self.endian() == 'big' and is_native_little) or\
+ * (self.endian() == 'little' and is_native_big):
+ * data.byteswap(True) # in-place byteswap # <<<<<<<<<<<<<<
+ * if not self.dimensions:
+ * return data[0] # a scalar
+ */
+ __pyx_tuple__80 = PyTuple_Pack(1, Py_True); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(0, 4455, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__80);
+ __Pyx_GIVEREF(__pyx_tuple__80);
/* "netCDF4/_netCDF4.pyx":4554
* if format.kind != 'V': # scalar primitive type
@@ -75320,9 +74477,9 @@ static int __Pyx_InitCachedConstants(void) {
* except KeyError:
* raise ValueError('Unsupported compound type element')
*/
- __pyx_slice__88 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__88)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4554; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__88);
- __Pyx_GIVEREF(__pyx_slice__88);
+ __pyx_slice__81 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__81)) __PYX_ERR(0, 4554, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__81);
+ __Pyx_GIVEREF(__pyx_slice__81);
/* "netCDF4/_netCDF4.pyx":4556
* xtype_tmp = _nptonctype[format.str[1:]]
@@ -75331,9 +74488,9 @@ static int __Pyx_InitCachedConstants(void) {
* ierr = nc_insert_compound(grp._grpid, xtype, namstring,
* offset, xtype_tmp)
*/
- __pyx_tuple__89 = PyTuple_Pack(1, __pyx_kp_s_Unsupported_compound_type_elemen); if (unlikely(!__pyx_tuple__89)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4556; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__89);
- __Pyx_GIVEREF(__pyx_tuple__89);
+ __pyx_tuple__82 = PyTuple_Pack(1, __pyx_kp_s_Unsupported_compound_type_elemen); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(0, 4556, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__82);
+ __Pyx_GIVEREF(__pyx_tuple__82);
/* "netCDF4/_netCDF4.pyx":4579
* if format.subdtype[0].str[1] != 'V': # primitive type.
@@ -75342,9 +74499,9 @@ static int __Pyx_InitCachedConstants(void) {
* except KeyError:
* raise ValueError('Unsupported compound type element')
*/
- __pyx_slice__90 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__90)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4579; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__90);
- __Pyx_GIVEREF(__pyx_slice__90);
+ __pyx_slice__83 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__83)) __PYX_ERR(0, 4579, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__83);
+ __Pyx_GIVEREF(__pyx_slice__83);
/* "netCDF4/_netCDF4.pyx":4581
* xtype_tmp = _nptonctype[format.subdtype[0].str[1:]]
@@ -75353,9 +74510,9 @@ static int __Pyx_InitCachedConstants(void) {
* ierr = nc_insert_array_compound(grp._grpid,xtype,namstring,
* offset,xtype_tmp,ndims,dim_sizes)
*/
- __pyx_tuple__91 = PyTuple_Pack(1, __pyx_kp_s_Unsupported_compound_type_elemen); if (unlikely(!__pyx_tuple__91)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4581; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__91);
- __Pyx_GIVEREF(__pyx_tuple__91);
+ __pyx_tuple__84 = PyTuple_Pack(1, __pyx_kp_s_Unsupported_compound_type_elemen); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(0, 4581, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__84);
+ __Pyx_GIVEREF(__pyx_tuple__84);
/* "netCDF4/_netCDF4.pyx":4619
* parent_grp = grp.parent
@@ -75364,9 +74521,9 @@ static int __Pyx_InitCachedConstants(void) {
* if parent_grp is None:
* raise ValueError("cannot find compound type in this group or parent groups")
*/
- __pyx_tuple__92 = PyTuple_Pack(1, __pyx_kp_s_cannot_find_compound_type_in_thi); if (unlikely(!__pyx_tuple__92)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4619; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__92);
- __Pyx_GIVEREF(__pyx_tuple__92);
+ __pyx_tuple__85 = PyTuple_Pack(1, __pyx_kp_s_cannot_find_compound_type_in_thi); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 4619, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__85);
+ __Pyx_GIVEREF(__pyx_tuple__85);
/* "netCDF4/_netCDF4.pyx":4621
* raise ValueError("cannot find compound type in this group or parent groups")
@@ -75375,9 +74532,9 @@ static int __Pyx_InitCachedConstants(void) {
* else:
* xtype = _find_cmptype(parent_grp,dtype)
*/
- __pyx_tuple__93 = PyTuple_Pack(1, __pyx_kp_s_cannot_find_compound_type_in_thi); if (unlikely(!__pyx_tuple__93)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4621; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__93);
- __Pyx_GIVEREF(__pyx_tuple__93);
+ __pyx_tuple__86 = PyTuple_Pack(1, __pyx_kp_s_cannot_find_compound_type_in_thi); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(0, 4621, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__86);
+ __Pyx_GIVEREF(__pyx_tuple__86);
/* "netCDF4/_netCDF4.pyx":4695
* field_type = _read_compound(group, field_typeid, endian=endian)
@@ -75386,9 +74543,9 @@ static int __Pyx_InitCachedConstants(void) {
* if field_shape != ():
* formats.append((field_type,field_shape))
*/
- __pyx_tuple__94 = PyTuple_Pack(1, __pyx_kp_s_compound_field_of_an_unsupported); if (unlikely(!__pyx_tuple__94)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4695; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__94);
- __Pyx_GIVEREF(__pyx_tuple__94);
+ __pyx_tuple__87 = PyTuple_Pack(1, __pyx_kp_s_compound_field_of_an_unsupported); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(0, 4695, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__87);
+ __Pyx_GIVEREF(__pyx_tuple__87);
/* "netCDF4/_netCDF4.pyx":4784
* namstring = bytestr
@@ -75397,9 +74554,9 @@ static int __Pyx_InitCachedConstants(void) {
* # find netCDF primitive data type corresponding to
* # specified numpy data type.
*/
- __pyx_slice__95 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__95)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4784; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__95);
- __Pyx_GIVEREF(__pyx_slice__95);
+ __pyx_slice__88 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__88)) __PYX_ERR(0, 4784, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__88);
+ __Pyx_GIVEREF(__pyx_slice__88);
/* "netCDF4/_netCDF4.pyx":4787
* # find netCDF primitive data type corresponding to
@@ -75408,9 +74565,9 @@ static int __Pyx_InitCachedConstants(void) {
* ierr = nc_def_vlen(grp._grpid, namstring, xtype_tmp, &xtype);
* if ierr != NC_NOERR:
*/
- __pyx_slice__96 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__96)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4787; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__96);
- __Pyx_GIVEREF(__pyx_slice__96);
+ __pyx_slice__89 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__89)) __PYX_ERR(0, 4787, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__89);
+ __Pyx_GIVEREF(__pyx_slice__89);
/* "netCDF4/_netCDF4.pyx":4792
* raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
@@ -75419,9 +74576,9 @@ static int __Pyx_InitCachedConstants(void) {
* return xtype, dt
*
*/
- __pyx_tuple__97 = PyTuple_Pack(1, __pyx_kp_s_unsupported_datatype_specified_f); if (unlikely(!__pyx_tuple__97)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4792; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__97);
- __Pyx_GIVEREF(__pyx_tuple__97);
+ __pyx_tuple__90 = PyTuple_Pack(1, __pyx_kp_s_unsupported_datatype_specified_f); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(0, 4792, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__90);
+ __Pyx_GIVEREF(__pyx_tuple__90);
/* "netCDF4/_netCDF4.pyx":4819
* dt = numpy.dtype(datatype) # see if it is a primitive type
@@ -75430,9 +74587,9 @@ static int __Pyx_InitCachedConstants(void) {
* return VLType(group, dt, name, typeid=xtype)
*
*/
- __pyx_tuple__98 = PyTuple_Pack(1, __pyx_kp_s_unsupported_component_type_for_V); if (unlikely(!__pyx_tuple__98)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4819; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__98);
- __Pyx_GIVEREF(__pyx_tuple__98);
+ __pyx_tuple__91 = PyTuple_Pack(1, __pyx_kp_s_unsupported_component_type_for_V); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(0, 4819, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__91);
+ __Pyx_GIVEREF(__pyx_tuple__91);
/* "netCDF4/_netCDF4.pyx":4893
* namstring = bytestr
@@ -75441,9 +74598,9 @@ static int __Pyx_InitCachedConstants(void) {
* # find netCDF primitive data type corresponding to
* # specified numpy data type.
*/
- __pyx_slice__99 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__99)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4893; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__99);
- __Pyx_GIVEREF(__pyx_slice__99);
+ __pyx_slice__92 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__92)) __PYX_ERR(0, 4893, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__92);
+ __Pyx_GIVEREF(__pyx_slice__92);
/* "netCDF4/_netCDF4.pyx":4896
* # find netCDF primitive data type corresponding to
@@ -75452,9 +74609,9 @@ static int __Pyx_InitCachedConstants(void) {
* ierr = nc_def_enum(grp._grpid, xtype_tmp, namstring, &xtype);
* if ierr != NC_NOERR:
*/
- __pyx_slice__100 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__100)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4896; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__100);
- __Pyx_GIVEREF(__pyx_slice__100);
+ __pyx_slice__93 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__93)) __PYX_ERR(0, 4896, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__93);
+ __Pyx_GIVEREF(__pyx_slice__93);
/* "netCDF4/_netCDF4.pyx":4937
* dt = numpy.dtype(datatype) # see if it is a primitive type
@@ -75463,9 +74620,9 @@ static int __Pyx_InitCachedConstants(void) {
* # loop over members, build dict.
* enum_dict = {}
*/
- __pyx_tuple__101 = PyTuple_Pack(1, __pyx_kp_s_unsupported_component_type_for_V); if (unlikely(!__pyx_tuple__101)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4937; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__101);
- __Pyx_GIVEREF(__pyx_tuple__101);
+ __pyx_tuple__94 = PyTuple_Pack(1, __pyx_kp_s_unsupported_component_type_for_V); if (unlikely(!__pyx_tuple__94)) __PYX_ERR(0, 4937, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__94);
+ __Pyx_GIVEREF(__pyx_tuple__94);
/* "netCDF4/_netCDF4.pyx":4965
* return str(bytestr,encoding='ascii')
@@ -75474,9 +74631,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* #----------------------------------------
*/
- __pyx_tuple__102 = PyTuple_Pack(1, __pyx_n_s_ascii); if (unlikely(!__pyx_tuple__102)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4965; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__102);
- __Pyx_GIVEREF(__pyx_tuple__102);
+ __pyx_tuple__95 = PyTuple_Pack(1, __pyx_n_s_ascii); if (unlikely(!__pyx_tuple__95)) __PYX_ERR(0, 4965, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__95);
+ __Pyx_GIVEREF(__pyx_tuple__95);
/* "netCDF4/_netCDF4.pyx":4985
* units = timestr_split[0].lower()
@@ -75485,9 +74642,9 @@ static int __Pyx_InitCachedConstants(void) {
* # parse the date string.
* n = timestr.find('since')+6
*/
- __pyx_tuple__103 = PyTuple_Pack(1, __pyx_kp_s_no_since_in_unit_string); if (unlikely(!__pyx_tuple__103)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4985; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__103);
- __Pyx_GIVEREF(__pyx_tuple__103);
+ __pyx_tuple__96 = PyTuple_Pack(1, __pyx_kp_s_no_since_in_unit_string); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(0, 4985, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__96);
+ __Pyx_GIVEREF(__pyx_tuple__96);
/* "netCDF4/_netCDF4.pyx":4987
* raise ValueError("no 'since' in unit_string")
@@ -75496,9 +74653,9 @@ static int __Pyx_InitCachedConstants(void) {
* isostring = timestr[n:]
* year, month, day, hour, minute, second, utc_offset =\
*/
- __pyx_tuple__104 = PyTuple_Pack(1, __pyx_n_s_since); if (unlikely(!__pyx_tuple__104)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__104);
- __Pyx_GIVEREF(__pyx_tuple__104);
+ __pyx_tuple__97 = PyTuple_Pack(1, __pyx_n_s_since); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(0, 4987, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__97);
+ __Pyx_GIVEREF(__pyx_tuple__97);
/* "netCDF4/_netCDF4.pyx":4999
* basedate = netcdftime.datetime(year, month, day, hour, minute, second)
@@ -75507,9 +74664,9 @@ static int __Pyx_InitCachedConstants(void) {
* return basedate
*
*/
- __pyx_tuple__105 = PyTuple_Pack(1, __pyx_kp_s_cannot_use_utc_offset_for_refere); if (unlikely(!__pyx_tuple__105)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__105);
- __Pyx_GIVEREF(__pyx_tuple__105);
+ __pyx_tuple__98 = PyTuple_Pack(1, __pyx_kp_s_cannot_use_utc_offset_for_refere); if (unlikely(!__pyx_tuple__98)) __PYX_ERR(0, 4999, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__98);
+ __Pyx_GIVEREF(__pyx_tuple__98);
/* "netCDF4/_netCDF4.pyx":5020
* (default) or `'U1'` (if dtype=`'U'`)"""
@@ -75518,9 +74675,9 @@ static int __Pyx_InitCachedConstants(void) {
* arr = numpy.zeros(NUMCHARS,dtype+'1')
* arr[0:len(string)] = tuple(string)
*/
- __pyx_tuple__106 = PyTuple_Pack(1, __pyx_kp_s_dtype_must_string_or_unicode_S_o); if (unlikely(!__pyx_tuple__106)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5020; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__106);
- __Pyx_GIVEREF(__pyx_tuple__106);
+ __pyx_tuple__99 = PyTuple_Pack(1, __pyx_kp_s_dtype_must_string_or_unicode_S_o); if (unlikely(!__pyx_tuple__99)) __PYX_ERR(0, 5020, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__99);
+ __Pyx_GIVEREF(__pyx_tuple__99);
/* "netCDF4/_netCDF4.pyx":5039
* dtype = a.dtype.kind
@@ -75529,9 +74686,9 @@ static int __Pyx_InitCachedConstants(void) {
* b = numpy.array(tuple(a.tostring().decode(default_encoding)),dtype+'1')
* b.shape = a.shape + (a.itemsize,)
*/
- __pyx_tuple__107 = PyTuple_Pack(1, __pyx_kp_s_type_must_string_or_unicode_S_or); if (unlikely(!__pyx_tuple__107)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5039; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__107);
- __Pyx_GIVEREF(__pyx_tuple__107);
+ __pyx_tuple__100 = PyTuple_Pack(1, __pyx_kp_s_type_must_string_or_unicode_S_or); if (unlikely(!__pyx_tuple__100)) __PYX_ERR(0, 5039, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__100);
+ __Pyx_GIVEREF(__pyx_tuple__100);
/* "netCDF4/_netCDF4.pyx":5058
* dtype = b.dtype.kind
@@ -75540,9 +74697,9 @@ static int __Pyx_InitCachedConstants(void) {
* bs = b.tostring().decode(default_encoding)
* slen = int(b.shape[-1])
*/
- __pyx_tuple__108 = PyTuple_Pack(1, __pyx_kp_s_type_must_string_or_unicode_S_or); if (unlikely(!__pyx_tuple__108)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__108);
- __Pyx_GIVEREF(__pyx_tuple__108);
+ __pyx_tuple__101 = PyTuple_Pack(1, __pyx_kp_s_type_must_string_or_unicode_S_or); if (unlikely(!__pyx_tuple__101)) __PYX_ERR(0, 5058, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__101);
+ __Pyx_GIVEREF(__pyx_tuple__101);
/* "netCDF4/_netCDF4.pyx":5062
* slen = int(b.shape[-1])
@@ -75551,9 +74708,9 @@ static int __Pyx_InitCachedConstants(void) {
* return a
*
*/
- __pyx_slice__109 = PySlice_New(Py_None, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_slice__109)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5062; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__109);
- __Pyx_GIVEREF(__pyx_slice__109);
+ __pyx_slice__102 = PySlice_New(Py_None, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_slice__102)) __PYX_ERR(0, 5062, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__102);
+ __Pyx_GIVEREF(__pyx_slice__102);
/* "netCDF4/_netCDF4.pyx":5144
* times.append(totaltime/1.e6/3600./24.)
@@ -75562,9 +74719,9 @@ static int __Pyx_InitCachedConstants(void) {
* if isscalar:
* return times[0]
*/
- __pyx_tuple__110 = PyTuple_Pack(1, __pyx_kp_s_unsupported_time_units); if (unlikely(!__pyx_tuple__110)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5144; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__110);
- __Pyx_GIVEREF(__pyx_tuple__110);
+ __pyx_tuple__103 = PyTuple_Pack(1, __pyx_kp_s_unsupported_time_units); if (unlikely(!__pyx_tuple__103)) __PYX_ERR(0, 5144, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__103);
+ __Pyx_GIVEREF(__pyx_tuple__103);
/* "netCDF4/_netCDF4.pyx":5238
* tsecs = time*86400.
@@ -75573,9 +74730,9 @@ static int __Pyx_InitCachedConstants(void) {
* # compute time delta.
* days = tsecs // 86400.
*/
- __pyx_tuple__111 = PyTuple_Pack(1, __pyx_kp_s_unsupported_time_units); if (unlikely(!__pyx_tuple__111)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__111);
- __Pyx_GIVEREF(__pyx_tuple__111);
+ __pyx_tuple__104 = PyTuple_Pack(1, __pyx_kp_s_unsupported_time_units); if (unlikely(!__pyx_tuple__104)) __PYX_ERR(0, 5238, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__104);
+ __Pyx_GIVEREF(__pyx_tuple__104);
/* "netCDF4/_netCDF4.pyx":5290
* nctime.units
@@ -75584,9 +74741,9 @@ static int __Pyx_InitCachedConstants(void) {
* if calendar == None:
* calendar = getattr(nctime, 'calendar', 'standard')
*/
- __pyx_tuple__112 = PyTuple_Pack(1, __pyx_kp_s_netcdf_time_variable_is_missing); if (unlikely(!__pyx_tuple__112)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5290; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__112);
- __Pyx_GIVEREF(__pyx_tuple__112);
+ __pyx_tuple__105 = PyTuple_Pack(1, __pyx_kp_s_netcdf_time_variable_is_missing); if (unlikely(!__pyx_tuple__105)) __PYX_ERR(0, 5290, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__105);
+ __Pyx_GIVEREF(__pyx_tuple__105);
/* "netCDF4/_netCDF4.pyx":5376
* # can be used like a CDF instance.
@@ -75595,9 +74752,9 @@ static int __Pyx_InitCachedConstants(void) {
* msg='cannot using file globbing for remote (OPeNDAP) datasets'
* raise ValueError(msg)
*/
- __pyx_tuple__113 = PyTuple_Pack(1, __pyx_n_s_http); if (unlikely(!__pyx_tuple__113)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5376; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__113);
- __Pyx_GIVEREF(__pyx_tuple__113);
+ __pyx_tuple__106 = PyTuple_Pack(1, __pyx_n_s_http); if (unlikely(!__pyx_tuple__106)) __PYX_ERR(0, 5376, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__106);
+ __Pyx_GIVEREF(__pyx_tuple__106);
/* "netCDF4/_netCDF4.pyx":5438
* # Make sure each file defines the same aggregation variables as the master
@@ -75606,9 +74763,9 @@ static int __Pyx_InitCachedConstants(void) {
* part = Dataset(f)
* varInfo = part.variables
*/
- __pyx_slice__114 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__114)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5438; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__114);
- __Pyx_GIVEREF(__pyx_slice__114);
+ __pyx_slice__107 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__107)) __PYX_ERR(0, 5438, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__107);
+ __Pyx_GIVEREF(__pyx_slice__107);
/* "netCDF4/_netCDF4.pyx":5449
* #if not vInst.dimensions[0] != aggDimName:
@@ -75617,9 +74774,9 @@ static int __Pyx_InitCachedConstants(void) {
* extDims = varInfo[v].dimensions
* extShape = varInfo[v].shape
*/
- __pyx_slice__115 = PySlice_New(Py_None, __pyx_int_3, Py_None); if (unlikely(!__pyx_slice__115)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5449; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__115);
- __Pyx_GIVEREF(__pyx_slice__115);
+ __pyx_slice__108 = PySlice_New(Py_None, __pyx_int_3, Py_None); if (unlikely(!__pyx_slice__108)) __PYX_ERR(0, 5449, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__108);
+ __Pyx_GIVEREF(__pyx_slice__108);
/* "netCDF4/_netCDF4.pyx":5466
* "master %s (%s) and extension %s (%s)" %
@@ -75628,12 +74785,12 @@ static int __Pyx_InitCachedConstants(void) {
* raise IOError("variable %s : shape mismatch between "
* "master %s (%s) and extension %s (%s)" %
*/
- __pyx_slice__116 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__116)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__116);
- __Pyx_GIVEREF(__pyx_slice__116);
- __pyx_slice__117 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__117)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5466; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__117);
- __Pyx_GIVEREF(__pyx_slice__117);
+ __pyx_slice__109 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__109)) __PYX_ERR(0, 5466, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__109);
+ __Pyx_GIVEREF(__pyx_slice__109);
+ __pyx_slice__110 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__110)) __PYX_ERR(0, 5466, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__110);
+ __Pyx_GIVEREF(__pyx_slice__110);
/* "netCDF4/_netCDF4.pyx":5509
* for dset in self._cdf:
@@ -75642,9 +74799,9 @@ static int __Pyx_InitCachedConstants(void) {
* self._file_format.append(dset.file_format)
* self._data_model.append(dset.data_model)
*/
- __pyx_tuple__118 = PyTuple_Pack(1, __pyx_kp_s_MFNetCDF4_only_works_with_NETCDF); if (unlikely(!__pyx_tuple__118)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5509; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__118);
- __Pyx_GIVEREF(__pyx_tuple__118);
+ __pyx_tuple__111 = PyTuple_Pack(1, __pyx_kp_s_MFNetCDF4_only_works_with_NETCDF); if (unlikely(!__pyx_tuple__111)) __PYX_ERR(0, 5509, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__111);
+ __Pyx_GIVEREF(__pyx_tuple__111);
/* "netCDF4/_netCDF4.pyx":5625
* def __len__(self):
@@ -75653,9 +74810,9 @@ static int __Pyx_InitCachedConstants(void) {
* else:
* return self._shape()[0]
*/
- __pyx_tuple__119 = PyTuple_Pack(1, __pyx_kp_s_len_of_unsized_object); if (unlikely(!__pyx_tuple__119)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5625; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__119);
- __Pyx_GIVEREF(__pyx_tuple__119);
+ __pyx_tuple__112 = PyTuple_Pack(1, __pyx_kp_s_len_of_unsized_object); if (unlikely(!__pyx_tuple__112)) __PYX_ERR(0, 5625, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__112);
+ __Pyx_GIVEREF(__pyx_tuple__112);
/* "netCDF4/_netCDF4.pyx":5630
* def _shape(self):
@@ -75664,9 +74821,9 @@ static int __Pyx_InitCachedConstants(void) {
* def set_auto_maskandscale(self,val):
* for v in self._recVar:
*/
- __pyx_slice__120 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__120)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5630; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__120);
- __Pyx_GIVEREF(__pyx_slice__120);
+ __pyx_slice__113 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__113)) __PYX_ERR(0, 5630, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__113);
+ __Pyx_GIVEREF(__pyx_slice__113);
/* "netCDF4/_netCDF4.pyx":5651
* # The convention used is that for those cases,
@@ -75675,9 +74832,9 @@ static int __Pyx_InitCachedConstants(void) {
* for i,n in enumerate(put_ind.shape[:-1]):
* if n == 1 and put_ind[...,i].ravel()[0] == -1:
*/
- __pyx_slice__121 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__121)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5651; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__121);
- __Pyx_GIVEREF(__pyx_slice__121);
+ __pyx_slice__114 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__114)) __PYX_ERR(0, 5651, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__114);
+ __Pyx_GIVEREF(__pyx_slice__114);
/* "netCDF4/_netCDF4.pyx":5652
* # put_ind for this dimension is set to -1 by _StartCountStride.
@@ -75686,9 +74843,9 @@ static int __Pyx_InitCachedConstants(void) {
* if n == 1 and put_ind[...,i].ravel()[0] == -1:
* squeeze[i] = 0
*/
- __pyx_slice__122 = PySlice_New(Py_None, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_slice__122)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5652; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__122);
- __Pyx_GIVEREF(__pyx_slice__122);
+ __pyx_slice__115 = PySlice_New(Py_None, __pyx_int_neg_1, Py_None); if (unlikely(!__pyx_slice__115)) __PYX_ERR(0, 5652, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__115);
+ __Pyx_GIVEREF(__pyx_slice__115);
/* "netCDF4/_netCDF4.pyx":5669
* count = [abs(cnt) for cnt in count]
@@ -75697,9 +74854,9 @@ static int __Pyx_InitCachedConstants(void) {
* # Start, stop and step along 1st dimension, eg the unlimited
* # dimension.
*/
- __pyx_tuple__123 = PyTuple_Pack(1, __pyx_kp_s_negative_strides_not_allowed_whe); if (unlikely(!__pyx_tuple__123)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5669; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__123);
- __Pyx_GIVEREF(__pyx_tuple__123);
+ __pyx_tuple__116 = PyTuple_Pack(1, __pyx_kp_s_negative_strides_not_allowed_whe); if (unlikely(!__pyx_tuple__116)) __PYX_ERR(0, 5669, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__116);
+ __Pyx_GIVEREF(__pyx_tuple__116);
/* "netCDF4/_netCDF4.pyx":5693
*
@@ -75708,9 +74865,9 @@ static int __Pyx_InitCachedConstants(void) {
* for n in range(1, len(start)): # skip dimension 0
* s = slice(start[n],start[n] + count[n] * stride[n], stride[n])
*/
- __pyx_slice__124 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__124)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5693; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_slice__124);
- __Pyx_GIVEREF(__pyx_slice__124);
+ __pyx_slice__117 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__117)) __PYX_ERR(0, 5693, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__117);
+ __Pyx_GIVEREF(__pyx_slice__117);
/* "netCDF4/_netCDF4.pyx":5795
* for t in self._recVar:
@@ -75719,9 +74876,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* # Check that calendar is the same in all files.
*/
- __pyx_tuple__125 = PyTuple_Pack(1, __pyx_kp_s_MFTime_requires_that_the_time_va); if (unlikely(!__pyx_tuple__125)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__125);
- __Pyx_GIVEREF(__pyx_tuple__125);
+ __pyx_tuple__118 = PyTuple_Pack(1, __pyx_kp_s_MFTime_requires_that_the_time_va); if (unlikely(!__pyx_tuple__118)) __PYX_ERR(0, 5795, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__118);
+ __Pyx_GIVEREF(__pyx_tuple__118);
/* "netCDF4/_netCDF4.pyx":5799
* # Check that calendar is the same in all files.
@@ -75730,9 +74887,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* # Override units if units is specified.
*/
- __pyx_tuple__126 = PyTuple_Pack(1, __pyx_kp_s_MFTime_requires_that_the_same_ti); if (unlikely(!__pyx_tuple__126)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5799; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__126);
- __Pyx_GIVEREF(__pyx_tuple__126);
+ __pyx_tuple__119 = PyTuple_Pack(1, __pyx_kp_s_MFTime_requires_that_the_same_ti); if (unlikely(!__pyx_tuple__119)) __PYX_ERR(0, 5799, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__119);
+ __Pyx_GIVEREF(__pyx_tuple__119);
/* "netCDF4/_netCDF4.pyx":5805
*
@@ -75741,86 +74898,108 @@ static int __Pyx_InitCachedConstants(void) {
* ref_num = date2num(ref_date, self.units, self.calendar)
*
*/
- __pyx_tuple__127 = PyTuple_Pack(3, __pyx_int_1900, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__127)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5805; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__127);
- __Pyx_GIVEREF(__pyx_tuple__127);
+ __pyx_tuple__120 = PyTuple_Pack(3, __pyx_int_1900, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__120)) __PYX_ERR(0, 5805, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__120);
+ __Pyx_GIVEREF(__pyx_tuple__120);
- /* "netCDF4/_netCDF4.pyx":928
+ /* "netCDF4/_netCDF4.pyx":931
* from ordereddict import OrderedDict
* except ImportError:
* raise ImportError('please install ordereddict (https://pypi.python.org/pypi/ordereddict)') # <<<<<<<<<<<<<<
* try:
* from itertools import izip as zip
*/
- __pyx_tuple__128 = PyTuple_Pack(1, __pyx_kp_s_please_install_ordereddict_https); if (unlikely(!__pyx_tuple__128)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__128);
- __Pyx_GIVEREF(__pyx_tuple__128);
+ __pyx_tuple__121 = PyTuple_Pack(1, __pyx_kp_s_please_install_ordereddict_https); if (unlikely(!__pyx_tuple__121)) __PYX_ERR(0, 931, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__121);
+ __Pyx_GIVEREF(__pyx_tuple__121);
- /* "netCDF4/_netCDF4.pyx":954
+ /* "netCDF4/_netCDF4.pyx":957
* # check for required version of netcdf-4 and hdf5.
*
* def _gethdf5libversion(): # <<<<<<<<<<<<<<
* majorvers = H5_VERS_MAJOR
* minorvers = H5_VERS_MINOR
*/
- __pyx_tuple__129 = PyTuple_Pack(4, __pyx_n_s_majorvers, __pyx_n_s_minorvers, __pyx_n_s_releasevers, __pyx_n_s_patchstring); if (unlikely(!__pyx_tuple__129)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__129);
- __Pyx_GIVEREF(__pyx_tuple__129);
- __pyx_codeobj__130 = (PyObject*)__Pyx_PyCode_New(0, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__129, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_gethdf5libversion, 954, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__130)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__122 = PyTuple_Pack(4, __pyx_n_s_majorvers, __pyx_n_s_minorvers, __pyx_n_s_releasevers, __pyx_n_s_patchstring); if (unlikely(!__pyx_tuple__122)) __PYX_ERR(0, 957, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__122);
+ __Pyx_GIVEREF(__pyx_tuple__122);
+ __pyx_codeobj__123 = (PyObject*)__Pyx_PyCode_New(0, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__122, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_gethdf5libversion, 957, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__123)) __PYX_ERR(0, 957, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":964
+ /* "netCDF4/_netCDF4.pyx":967
* return '%d.%d.%d-%s' % (majorvers,minorvers,releasevers,patchstring)
*
* def getlibversion(): # <<<<<<<<<<<<<<
* """
* **`getlibversion()`**
*/
- __pyx_codeobj__131 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_getlibversion, 964, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__131)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_codeobj__124 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_getlibversion, 967, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__124)) __PYX_ERR(0, 967, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":980
+ /* "netCDF4/_netCDF4.pyx":983
* __has_cdf5__ = HAS_CDF5_FORMAT
* _needsworkaround_issue485 = __netcdf4libversion__ < "4.4.0" or \
* (__netcdf4libversion__.startswith("4.4.0") and \ # <<<<<<<<<<<<<<
* "-development" in __netcdf4libversion__)
*
*/
- __pyx_tuple__132 = PyTuple_Pack(1, __pyx_kp_s_4_4_0); if (unlikely(!__pyx_tuple__132)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__132);
- __Pyx_GIVEREF(__pyx_tuple__132);
+ __pyx_tuple__125 = PyTuple_Pack(1, __pyx_kp_s_4_4_0); if (unlikely(!__pyx_tuple__125)) __PYX_ERR(0, 983, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__125);
+ __Pyx_GIVEREF(__pyx_tuple__125);
- /* "netCDF4/_netCDF4.pyx":1040
+ /* "netCDF4/_netCDF4.pyx":987
+ *
+ * # issue warning for hdf5 1.10 (issue #549)
+ * if __netcdf4libversion__[0:5] < "4.4.1" and\ # <<<<<<<<<<<<<<
+ * __hdf5libversion__.startswith("1.10"):
+ * msg = """
+ */
+ __pyx_slice__126 = PySlice_New(__pyx_int_0, __pyx_int_5, Py_None); if (unlikely(!__pyx_slice__126)) __PYX_ERR(0, 987, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_slice__126);
+ __Pyx_GIVEREF(__pyx_slice__126);
+
+ /* "netCDF4/_netCDF4.pyx":988
+ * # issue warning for hdf5 1.10 (issue #549)
+ * if __netcdf4libversion__[0:5] < "4.4.1" and\
+ * __hdf5libversion__.startswith("1.10"): # <<<<<<<<<<<<<<
+ * msg = """
+ * WARNING: Backwards incompatible files will be created with HDF5 1.10.x
+ */
+ __pyx_tuple__127 = PyTuple_Pack(1, __pyx_kp_s_1_10); if (unlikely(!__pyx_tuple__127)) __PYX_ERR(0, 988, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__127);
+ __Pyx_GIVEREF(__pyx_tuple__127);
+
+ /* "netCDF4/_netCDF4.pyx":1053
*
* # logical for native endian type.
* is_native_little = numpy.dtype('<f4').byteorder == '=' # <<<<<<<<<<<<<<
* is_native_big = numpy.dtype('>f4').byteorder == '='
*
*/
- __pyx_tuple__133 = PyTuple_Pack(1, __pyx_kp_s_f4_2); if (unlikely(!__pyx_tuple__133)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__133);
- __Pyx_GIVEREF(__pyx_tuple__133);
+ __pyx_tuple__128 = PyTuple_Pack(1, __pyx_kp_s_f4_2); if (unlikely(!__pyx_tuple__128)) __PYX_ERR(0, 1053, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__128);
+ __Pyx_GIVEREF(__pyx_tuple__128);
- /* "netCDF4/_netCDF4.pyx":1041
+ /* "netCDF4/_netCDF4.pyx":1054
* # logical for native endian type.
* is_native_little = numpy.dtype('<f4').byteorder == '='
* is_native_big = numpy.dtype('>f4').byteorder == '=' # <<<<<<<<<<<<<<
*
* # hard code this here, instead of importing from netcdf.h
*/
- __pyx_tuple__134 = PyTuple_Pack(1, __pyx_kp_s_f4_3); if (unlikely(!__pyx_tuple__134)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__134);
- __Pyx_GIVEREF(__pyx_tuple__134);
+ __pyx_tuple__129 = PyTuple_Pack(1, __pyx_kp_s_f4_3); if (unlikely(!__pyx_tuple__129)) __PYX_ERR(0, 1054, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__129);
+ __Pyx_GIVEREF(__pyx_tuple__129);
- /* "netCDF4/_netCDF4.pyx":1156
+ /* "netCDF4/_netCDF4.pyx":1169
* return value_arr
*
* def _set_default_format(object format='NETCDF4'): # <<<<<<<<<<<<<<
* # Private function to set the netCDF file format
* if format not in _format_dict:
*/
- __pyx_tuple__135 = PyTuple_Pack(1, __pyx_n_s_format); if (unlikely(!__pyx_tuple__135)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1156; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__135);
- __Pyx_GIVEREF(__pyx_tuple__135);
- __pyx_codeobj__136 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__135, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_set_default_format, 1156, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__136)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1156; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__130 = PyTuple_Pack(1, __pyx_n_s_format); if (unlikely(!__pyx_tuple__130)) __PYX_ERR(0, 1169, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__130);
+ __Pyx_GIVEREF(__pyx_tuple__130);
+ __pyx_codeobj__131 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__130, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_set_default_format, 1169, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__131)) __PYX_ERR(0, 1169, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4960
* return pystr # already bytes or unicode?
@@ -75829,10 +75008,10 @@ static int __Pyx_InitCachedConstants(void) {
* # encode a byte string to an ascii encoded string.
* if python3:
*/
- __pyx_tuple__137 = PyTuple_Pack(1, __pyx_n_s_bytestr); if (unlikely(!__pyx_tuple__137)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__137);
- __Pyx_GIVEREF(__pyx_tuple__137);
- __pyx_codeobj__138 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__137, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_to_ascii, 4960, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__138)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__132 = PyTuple_Pack(1, __pyx_n_s_bytestr); if (unlikely(!__pyx_tuple__132)) __PYX_ERR(0, 4960, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__132);
+ __Pyx_GIVEREF(__pyx_tuple__132);
+ __pyx_codeobj__133 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__132, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_to_ascii, 4960, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__133)) __PYX_ERR(0, 4960, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":4975
*
@@ -75841,9 +75020,9 @@ static int __Pyx_InitCachedConstants(void) {
*
* def _dateparse(timestr):
*/
- __pyx_tuple__139 = PyTuple_Pack(3, __pyx_int_1582, __pyx_int_10, __pyx_int_15); if (unlikely(!__pyx_tuple__139)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__139);
- __Pyx_GIVEREF(__pyx_tuple__139);
+ __pyx_tuple__134 = PyTuple_Pack(3, __pyx_int_1582, __pyx_int_10, __pyx_int_15); if (unlikely(!__pyx_tuple__134)) __PYX_ERR(0, 4975, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__134);
+ __Pyx_GIVEREF(__pyx_tuple__134);
/* "netCDF4/_netCDF4.pyx":4977
* gregorian = datetime(1582,10,15)
@@ -75852,10 +75031,10 @@ static int __Pyx_InitCachedConstants(void) {
* """parse a string of the form time-units since yyyy-mm-dd hh:mm:ss,
* return a datetime instance"""
*/
- __pyx_tuple__140 = PyTuple_Pack(13, __pyx_n_s_timestr, __pyx_n_s_timestr_split, __pyx_n_s_units, __pyx_n_s_n, __pyx_n_s_isostring, __pyx_n_s_year, __pyx_n_s_month, __pyx_n_s_day, __pyx_n_s_hour, __pyx_n_s_minute, __pyx_n_s_second, __pyx_n_s_utc_offset, __pyx_n_s_basedate); if (unlikely(!__pyx_tuple__140)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__140);
- __Pyx_GIVEREF(__pyx_tuple__140);
- __pyx_codeobj__141 = (PyObject*)__Pyx_PyCode_New(1, 0, 13, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__140, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_dateparse, 4977, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__141)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__135 = PyTuple_Pack(13, __pyx_n_s_timestr, __pyx_n_s_timestr_split, __pyx_n_s_units, __pyx_n_s_n, __pyx_n_s_isostring, __pyx_n_s_year, __pyx_n_s_month, __pyx_n_s_day, __pyx_n_s_hour, __pyx_n_s_minute, __pyx_n_s_second, __pyx_n_s_utc_offset, __pyx_n_s_basedate); if (unlikely(!__pyx_tuple__135)) __PYX_ERR(0, 4977, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__135);
+ __Pyx_GIVEREF(__pyx_tuple__135);
+ __pyx_codeobj__136 = (PyObject*)__Pyx_PyCode_New(1, 0, 13, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__135, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_dateparse, 4977, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__136)) __PYX_ERR(0, 4977, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5002
* return basedate
@@ -75864,10 +75043,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`stringtoarr(a, NUMCHARS,dtype='S')`**
*/
- __pyx_tuple__142 = PyTuple_Pack(4, __pyx_n_s_string, __pyx_n_s_NUMCHARS, __pyx_n_s_dtype, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__142)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__142);
- __Pyx_GIVEREF(__pyx_tuple__142);
- __pyx_codeobj__143 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__142, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_stringtoarr, 5002, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__143)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__137 = PyTuple_Pack(4, __pyx_n_s_string, __pyx_n_s_NUMCHARS, __pyx_n_s_dtype, __pyx_n_s_arr); if (unlikely(!__pyx_tuple__137)) __PYX_ERR(0, 5002, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__137);
+ __Pyx_GIVEREF(__pyx_tuple__137);
+ __pyx_codeobj__138 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__137, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_stringtoarr, 5002, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__138)) __PYX_ERR(0, 5002, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5025
* return arr
@@ -75876,10 +75055,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`stringtochar(a)`**
*/
- __pyx_tuple__144 = PyTuple_Pack(3, __pyx_n_s_a, __pyx_n_s_dtype, __pyx_n_s_b); if (unlikely(!__pyx_tuple__144)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__144);
- __Pyx_GIVEREF(__pyx_tuple__144);
- __pyx_codeobj__145 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__144, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_stringtochar, 5025, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__145)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__139 = PyTuple_Pack(3, __pyx_n_s_a, __pyx_n_s_dtype, __pyx_n_s_b); if (unlikely(!__pyx_tuple__139)) __PYX_ERR(0, 5025, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__139);
+ __Pyx_GIVEREF(__pyx_tuple__139);
+ __pyx_codeobj__140 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__139, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_stringtochar, 5025, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__140)) __PYX_ERR(0, 5025, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5044
* return b
@@ -75888,10 +75067,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`chartostring(b)`**
*/
- __pyx_tuple__146 = PyTuple_Pack(6, __pyx_n_s_b, __pyx_n_s_dtype, __pyx_n_s_bs, __pyx_n_s_slen, __pyx_n_s_a, __pyx_n_s_n1); if (unlikely(!__pyx_tuple__146)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__146);
- __Pyx_GIVEREF(__pyx_tuple__146);
- __pyx_codeobj__147 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__146, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_chartostring, 5044, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__147)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__141 = PyTuple_Pack(6, __pyx_n_s_b, __pyx_n_s_dtype, __pyx_n_s_bs, __pyx_n_s_slen, __pyx_n_s_a, __pyx_n_s_n1); if (unlikely(!__pyx_tuple__141)) __PYX_ERR(0, 5044, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__141);
+ __Pyx_GIVEREF(__pyx_tuple__141);
+ __pyx_codeobj__142 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__141, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_chartostring, 5044, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__142)) __PYX_ERR(0, 5044, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5065
* return a
@@ -75900,10 +75079,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`date2num(dates,units,calendar='standard')`**
*/
- __pyx_tuple__148 = PyTuple_Pack(15, __pyx_n_s_dates, __pyx_n_s_units, __pyx_n_s_calendar, __pyx_n_s_basedate, __pyx_n_s_unit, __pyx_n_s_msg, __pyx_n_s_isscalar, __pyx_n_s_shape, __pyx_n_s_ismasked, __pyx_n_s_mask, __pyx_n_s_times, __pyx_n_s_date, __pyx_n_s_td, __pyx_n_s_totaltime, __pyx_n_s_cdftime); if (unlikely(!__pyx_tuple__148)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5065; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__148);
- __Pyx_GIVEREF(__pyx_tuple__148);
- __pyx_codeobj__149 = (PyObject*)__Pyx_PyCode_New(3, 0, 15, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__148, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_date2num, 5065, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__149)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5065; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__143 = PyTuple_Pack(15, __pyx_n_s_dates, __pyx_n_s_units, __pyx_n_s_calendar, __pyx_n_s_basedate, __pyx_n_s_unit, __pyx_n_s_msg, __pyx_n_s_isscalar, __pyx_n_s_shape, __pyx_n_s_ismasked, __pyx_n_s_mask, __pyx_n_s_times, __pyx_n_s_date, __pyx_n_s_td, __pyx_n_s_totaltime, __pyx_n_s_cdftime); if (unlikely(!__pyx_tuple__143)) __PYX_ERR(0, 5065, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__143);
+ __Pyx_GIVEREF(__pyx_tuple__143);
+ __pyx_codeobj__144 = (PyObject*)__Pyx_PyCode_New(3, 0, 15, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__143, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_date2num, 5065, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__144)) __PYX_ERR(0, 5065, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5153
* return cdftime.date2num(dates)
@@ -75912,10 +75091,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`num2date(times,units,calendar='standard')`**
*/
- __pyx_tuple__150 = PyTuple_Pack(20, __pyx_n_s_times, __pyx_n_s_units, __pyx_n_s_calendar, __pyx_n_s_basedate, __pyx_n_s_unit, __pyx_n_s_msg, __pyx_n_s_isscalar, __pyx_n_s_shape, __pyx_n_s_ismasked, __pyx_n_s_mask, __pyx_n_s_dates, __pyx_n_s_time, __pyx_n_s_tsecs, __pyx_n_s_days, __pyx_n_s_msecsd, __pyx_n_s_secs, __pyx_n_s_msecs, __pyx_n_s_td, __pyx_n_s_date, __pyx_n_s_cdftime); if (unlikely(!__pyx_tuple__150)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5153; __pyx_clineno = __LINE__; [...]
- __Pyx_GOTREF(__pyx_tuple__150);
- __Pyx_GIVEREF(__pyx_tuple__150);
- __pyx_codeobj__151 = (PyObject*)__Pyx_PyCode_New(3, 0, 20, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__150, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_num2date, 5153, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__151)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5153; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__145 = PyTuple_Pack(20, __pyx_n_s_times, __pyx_n_s_units, __pyx_n_s_calendar, __pyx_n_s_basedate, __pyx_n_s_unit, __pyx_n_s_msg, __pyx_n_s_isscalar, __pyx_n_s_shape, __pyx_n_s_ismasked, __pyx_n_s_mask, __pyx_n_s_dates, __pyx_n_s_time, __pyx_n_s_tsecs, __pyx_n_s_days, __pyx_n_s_msecsd, __pyx_n_s_secs, __pyx_n_s_msecs, __pyx_n_s_td, __pyx_n_s_date, __pyx_n_s_cdftime); if (unlikely(!__pyx_tuple__145)) __PYX_ERR(0, 5153, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__145);
+ __Pyx_GIVEREF(__pyx_tuple__145);
+ __pyx_codeobj__146 = (PyObject*)__Pyx_PyCode_New(3, 0, 20, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__145, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_num2date, 5153, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__146)) __PYX_ERR(0, 5153, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5256
* return cdftime.num2date(times)
@@ -75924,10 +75103,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`date2index(dates, nctime, calendar=None, select='exact')`**
*/
- __pyx_tuple__152 = PyTuple_Pack(7, __pyx_n_s_dates, __pyx_n_s_nctime, __pyx_n_s_calendar, __pyx_n_s_select, __pyx_n_s_basedate, __pyx_n_s_msg, __pyx_n_s_times); if (unlikely(!__pyx_tuple__152)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__152);
- __Pyx_GIVEREF(__pyx_tuple__152);
- __pyx_codeobj__153 = (PyObject*)__Pyx_PyCode_New(4, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__152, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_date2index, 5256, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__153)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__147 = PyTuple_Pack(7, __pyx_n_s_dates, __pyx_n_s_nctime, __pyx_n_s_calendar, __pyx_n_s_select, __pyx_n_s_basedate, __pyx_n_s_msg, __pyx_n_s_times); if (unlikely(!__pyx_tuple__147)) __PYX_ERR(0, 5256, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__147);
+ __Pyx_GIVEREF(__pyx_tuple__147);
+ __pyx_codeobj__148 = (PyObject*)__Pyx_PyCode_New(4, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__147, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_date2index, 5256, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__148)) __PYX_ERR(0, 5256, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5342
* """
@@ -75936,10 +75115,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`__init__(self, files, check=False, aggdim=None, exclude=[])`**
*/
- __pyx_tuple__154 = PyTuple_Pack(36, __pyx_n_s_self, __pyx_n_s_files, __pyx_n_s_check, __pyx_n_s_aggdim, __pyx_n_s_exclude, __pyx_n_s_msg, __pyx_n_s_master, __pyx_n_s_cdfm, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_aggDimId, __pyx_n_s_dimname, __pyx_n_s_dim, __pyx_n_s_aggDimName, __pyx_n_s_masterRecVar, __pyx_n_s_vName, __pyx_n_s_v, __pyx_n_s_dims_2, __pyx_n_s_shape, __pyx_n_s_dtype, __pyx_n_s_cdf_2, __pyx_n_s_cdfVLen_2, __pyx_n_s_cdfRecVar_2, __pyx_n_s_f, __pyx_n_s_part, __pyx_n_s_var [...]
- __Pyx_GOTREF(__pyx_tuple__154);
- __Pyx_GIVEREF(__pyx_tuple__154);
- __pyx_codeobj__155 = (PyObject*)__Pyx_PyCode_New(5, 0, 36, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__154, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_init, 5342, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__155)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__149 = PyTuple_Pack(36, __pyx_n_s_self, __pyx_n_s_files, __pyx_n_s_check, __pyx_n_s_aggdim, __pyx_n_s_exclude, __pyx_n_s_msg, __pyx_n_s_master, __pyx_n_s_cdfm, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_aggDimId, __pyx_n_s_dimname, __pyx_n_s_dim, __pyx_n_s_aggDimName, __pyx_n_s_masterRecVar, __pyx_n_s_vName, __pyx_n_s_v, __pyx_n_s_dims_2, __pyx_n_s_shape, __pyx_n_s_dtype, __pyx_n_s_cdf_2, __pyx_n_s_cdfVLen_2, __pyx_n_s_cdfRecVar_2, __pyx_n_s_f, __pyx_n_s_part, __pyx_n_s_var [...]
+ __Pyx_GOTREF(__pyx_tuple__149);
+ __Pyx_GIVEREF(__pyx_tuple__149);
+ __pyx_codeobj__150 = (PyObject*)__Pyx_PyCode_New(5, 0, 36, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__149, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_init, 5342, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__150)) __PYX_ERR(0, 5342, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5515
* self._path = '/'
@@ -75948,10 +75127,10 @@ static int __Pyx_InitCachedConstants(void) {
* """override base class attribute creation"""
* self.__dict__[name] = value
*/
- __pyx_tuple__156 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_value); if (unlikely(!__pyx_tuple__156)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5515; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__156);
- __Pyx_GIVEREF(__pyx_tuple__156);
- __pyx_codeobj__157 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__156, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_setattr, 5515, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__157)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5515; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__151 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_value); if (unlikely(!__pyx_tuple__151)) __PYX_ERR(0, 5515, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__151);
+ __Pyx_GIVEREF(__pyx_tuple__151);
+ __pyx_codeobj__152 = (PyObject*)__Pyx_PyCode_New(3, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__151, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_setattr, 5515, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__152)) __PYX_ERR(0, 5515, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5519
* self.__dict__[name] = value
@@ -75960,10 +75139,10 @@ static int __Pyx_InitCachedConstants(void) {
* if name in ['variables','dimensions','file_format','groups',\
* 'data_model','disk_format','path']:
*/
- __pyx_tuple__158 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_name); if (unlikely(!__pyx_tuple__158)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__158);
- __Pyx_GIVEREF(__pyx_tuple__158);
- __pyx_codeobj__159 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__158, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_getattribute, 5519, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__159)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__153 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_name); if (unlikely(!__pyx_tuple__153)) __PYX_ERR(0, 5519, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__153);
+ __Pyx_GIVEREF(__pyx_tuple__153);
+ __pyx_codeobj__154 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__153, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_getattribute, 5519, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__154)) __PYX_ERR(0, 5519, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5532
* return Dataset.__getattribute__(self, name)
@@ -75972,10 +75151,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`ncattrs(self)`**
*/
- __pyx_tuple__160 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__160)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5532; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__160);
- __Pyx_GIVEREF(__pyx_tuple__160);
- __pyx_codeobj__161 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__160, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_ncattrs, 5532, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__161)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5532; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__155 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__155)) __PYX_ERR(0, 5532, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__155);
+ __Pyx_GIVEREF(__pyx_tuple__155);
+ __pyx_codeobj__156 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__155, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_ncattrs, 5532, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__156)) __PYX_ERR(0, 5532, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5540
* return self._cdf[0].__dict__.keys()
@@ -75984,10 +75163,10 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`close(self)`**
*/
- __pyx_tuple__162 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_dset); if (unlikely(!__pyx_tuple__162)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__162);
- __Pyx_GIVEREF(__pyx_tuple__162);
- __pyx_codeobj__163 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__162, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_close, 5540, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__163)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__157 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_dset); if (unlikely(!__pyx_tuple__157)) __PYX_ERR(0, 5540, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__157);
+ __Pyx_GIVEREF(__pyx_tuple__157);
+ __pyx_codeobj__158 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__157, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_close, 5540, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__158)) __PYX_ERR(0, 5540, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5549
* dset.close()
@@ -75996,10 +75175,10 @@ static int __Pyx_InitCachedConstants(void) {
* ncdump = ['%r\n' % type(self)]
* dimnames = tuple([str(dimname) for dimname in self.dimensions.keys()])
*/
- __pyx_tuple__164 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_ncdump, __pyx_n_s_dimnames, __pyx_n_s_varnames, __pyx_n_s_grpnames, __pyx_n_s_attrs, __pyx_n_s_dimname, __pyx_n_s_varname, __pyx_n_s_name); if (unlikely(!__pyx_tuple__164)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__164);
- __Pyx_GIVEREF(__pyx_tuple__164);
- __pyx_codeobj__165 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__164, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_repr, 5549, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__165)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__159 = PyTuple_Pack(9, __pyx_n_s_self, __pyx_n_s_ncdump, __pyx_n_s_dimnames, __pyx_n_s_varnames, __pyx_n_s_grpnames, __pyx_n_s_attrs, __pyx_n_s_dimname, __pyx_n_s_varname, __pyx_n_s_name); if (unlikely(!__pyx_tuple__159)) __PYX_ERR(0, 5549, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__159);
+ __Pyx_GIVEREF(__pyx_tuple__159);
+ __pyx_codeobj__160 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__159, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_repr, 5549, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__160)) __PYX_ERR(0, 5549, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5568
*
@@ -76008,10 +75187,10 @@ static int __Pyx_InitCachedConstants(void) {
* self.dimlens = dimlens
* self.dimtotlen = dimtotlen
*/
- __pyx_tuple__166 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_dimname, __pyx_n_s_dim, __pyx_n_s_dimlens, __pyx_n_s_dimtotlen); if (unlikely(!__pyx_tuple__166)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__166);
- __Pyx_GIVEREF(__pyx_tuple__166);
- __pyx_codeobj__167 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__166, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_init, 5568, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__167)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__161 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_dimname, __pyx_n_s_dim, __pyx_n_s_dimlens, __pyx_n_s_dimtotlen); if (unlikely(!__pyx_tuple__161)) __PYX_ERR(0, 5568, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__161);
+ __Pyx_GIVEREF(__pyx_tuple__161);
+ __pyx_codeobj__162 = (PyObject*)__Pyx_PyCode_New(5, 0, 5, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__161, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_init, 5568, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__162)) __PYX_ERR(0, 5568, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5572
* self.dimtotlen = dimtotlen
@@ -76020,10 +75199,10 @@ static int __Pyx_InitCachedConstants(void) {
* return self.dimtotlen
* def isunlimited(self):
*/
- __pyx_tuple__168 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__168)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5572; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__168);
- __Pyx_GIVEREF(__pyx_tuple__168);
- __pyx_codeobj__169 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__168, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_len, 5572, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__169)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5572; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__163 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__163)) __PYX_ERR(0, 5572, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__163);
+ __Pyx_GIVEREF(__pyx_tuple__163);
+ __pyx_codeobj__164 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__163, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_len, 5572, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__164)) __PYX_ERR(0, 5572, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5574
* def __len__(self):
@@ -76032,10 +75211,10 @@ static int __Pyx_InitCachedConstants(void) {
* return True
* def __repr__(self):
*/
- __pyx_tuple__170 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__170)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5574; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__170);
- __Pyx_GIVEREF(__pyx_tuple__170);
- __pyx_codeobj__171 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__170, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_isunlimited, 5574, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__171)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5574; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__165 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__165)) __PYX_ERR(0, 5574, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__165);
+ __Pyx_GIVEREF(__pyx_tuple__165);
+ __pyx_codeobj__166 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__165, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_isunlimited, 5574, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__166)) __PYX_ERR(0, 5574, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5576
* def isunlimited(self):
@@ -76044,10 +75223,10 @@ static int __Pyx_InitCachedConstants(void) {
* if self.isunlimited():
* return repr(type(self))+" (unlimited): name = '%s', size = %s\n" % (self._name,len(self))
*/
- __pyx_tuple__172 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__172)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5576; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__172);
- __Pyx_GIVEREF(__pyx_tuple__172);
- __pyx_codeobj__173 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__172, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_repr, 5576, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__173)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5576; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__167 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__167)) __PYX_ERR(0, 5576, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__167);
+ __Pyx_GIVEREF(__pyx_tuple__167);
+ __pyx_codeobj__168 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__167, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_repr, 5576, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__168)) __PYX_ERR(0, 5576, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5583
*
@@ -76056,10 +75235,10 @@ static int __Pyx_InitCachedConstants(void) {
* self.dimensions = var.dimensions
* self._dset = dset
*/
- __pyx_tuple__174 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_dset, __pyx_n_s_varname, __pyx_n_s_var, __pyx_n_s_recdimname, __pyx_n_s_name, __pyx_n_s_value); if (unlikely(!__pyx_tuple__174)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__174);
- __Pyx_GIVEREF(__pyx_tuple__174);
- __pyx_codeobj__175 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__174, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_init, 5583, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__175)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__169 = PyTuple_Pack(7, __pyx_n_s_self, __pyx_n_s_dset, __pyx_n_s_varname, __pyx_n_s_var, __pyx_n_s_recdimname, __pyx_n_s_name, __pyx_n_s_value); if (unlikely(!__pyx_tuple__169)) __PYX_ERR(0, 5583, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__169);
+ __Pyx_GIVEREF(__pyx_tuple__169);
+ __pyx_codeobj__170 = (PyObject*)__Pyx_PyCode_New(5, 0, 7, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__169, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_init, 5583, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__170)) __PYX_ERR(0, 5583, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5596
* for name, value in var.__dict__.items():
@@ -76068,10 +75247,10 @@ static int __Pyx_InitCachedConstants(void) {
* return self.dtype
* def ncattrs(self):
*/
- __pyx_tuple__176 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__176)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5596; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__176);
- __Pyx_GIVEREF(__pyx_tuple__176);
- __pyx_codeobj__177 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__176, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_typecode, 5596, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__177)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5596; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__171 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__171)) __PYX_ERR(0, 5596, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__171);
+ __Pyx_GIVEREF(__pyx_tuple__171);
+ __pyx_codeobj__172 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__171, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_typecode, 5596, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__172)) __PYX_ERR(0, 5596, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5598
* def typecode(self):
@@ -76080,10 +75259,10 @@ static int __Pyx_InitCachedConstants(void) {
* return self._mastervar.__dict__.keys()
* def __getattr__(self,name):
*/
- __pyx_tuple__178 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__178)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5598; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__178);
- __Pyx_GIVEREF(__pyx_tuple__178);
- __pyx_codeobj__179 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__178, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_ncattrs, 5598, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__179)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5598; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__173 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__173)) __PYX_ERR(0, 5598, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__173);
+ __Pyx_GIVEREF(__pyx_tuple__173);
+ __pyx_codeobj__174 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__173, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_ncattrs, 5598, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__174)) __PYX_ERR(0, 5598, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5600
* def ncattrs(self):
@@ -76092,10 +75271,10 @@ static int __Pyx_InitCachedConstants(void) {
* if name == 'shape': return self._shape()
* if name == 'ndim': return len(self._shape())
*/
- __pyx_tuple__180 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_name); if (unlikely(!__pyx_tuple__180)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5600; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__180);
- __Pyx_GIVEREF(__pyx_tuple__180);
- __pyx_codeobj__181 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__180, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_getattr, 5600, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__181)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5600; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__175 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_name); if (unlikely(!__pyx_tuple__175)) __PYX_ERR(0, 5600, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__175);
+ __Pyx_GIVEREF(__pyx_tuple__175);
+ __pyx_codeobj__176 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__175, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_getattr, 5600, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__176)) __PYX_ERR(0, 5600, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5607
* except:
@@ -76104,10 +75283,10 @@ static int __Pyx_InitCachedConstants(void) {
* ncdump_var = ['%r\n' % type(self)]
* dimnames = tuple([str(dimname) for dimname in self.dimensions])
*/
- __pyx_tuple__182 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_ncdump_var, __pyx_n_s_dimnames, __pyx_n_s_attrs, __pyx_n_s_unlimdims, __pyx_n_s_dimname, __pyx_n_s_dim, __pyx_n_s_name); if (unlikely(!__pyx_tuple__182)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__182);
- __Pyx_GIVEREF(__pyx_tuple__182);
- __pyx_codeobj__183 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__182, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_repr, 5607, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__183)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__177 = PyTuple_Pack(8, __pyx_n_s_self, __pyx_n_s_ncdump_var, __pyx_n_s_dimnames, __pyx_n_s_attrs, __pyx_n_s_unlimdims, __pyx_n_s_dimname, __pyx_n_s_dim, __pyx_n_s_name); if (unlikely(!__pyx_tuple__177)) __PYX_ERR(0, 5607, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__177);
+ __Pyx_GIVEREF(__pyx_tuple__177);
+ __pyx_codeobj__178 = (PyObject*)__Pyx_PyCode_New(1, 0, 8, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__177, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_repr, 5607, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__178)) __PYX_ERR(0, 5607, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5623
* ncdump_var.append('current size = %s\n' % repr(self.shape))
@@ -76116,10 +75295,10 @@ static int __Pyx_InitCachedConstants(void) {
* if not self._shape:
* raise TypeError('len() of unsized object')
*/
- __pyx_tuple__184 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__184)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__184);
- __Pyx_GIVEREF(__pyx_tuple__184);
- __pyx_codeobj__185 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__184, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_len, 5623, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__185)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__179 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__179)) __PYX_ERR(0, 5623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__179);
+ __Pyx_GIVEREF(__pyx_tuple__179);
+ __pyx_codeobj__180 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__179, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_len, 5623, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__180)) __PYX_ERR(0, 5623, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5628
* else:
@@ -76128,10 +75307,10 @@ static int __Pyx_InitCachedConstants(void) {
* recdimlen = len(self._dset.dimensions[self._recdimname])
* return (recdimlen,) + self._mastervar.shape[1:]
*/
- __pyx_tuple__186 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_recdimlen); if (unlikely(!__pyx_tuple__186)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5628; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__186);
- __Pyx_GIVEREF(__pyx_tuple__186);
- __pyx_codeobj__187 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__186, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_shape_2, 5628, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__187)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5628; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__181 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_recdimlen); if (unlikely(!__pyx_tuple__181)) __PYX_ERR(0, 5628, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__181);
+ __Pyx_GIVEREF(__pyx_tuple__181);
+ __pyx_codeobj__182 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__181, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_shape_2, 5628, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__182)) __PYX_ERR(0, 5628, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5631
* recdimlen = len(self._dset.dimensions[self._recdimname])
@@ -76140,10 +75319,10 @@ static int __Pyx_InitCachedConstants(void) {
* for v in self._recVar:
* v.set_auto_maskandscale(val)
*/
- __pyx_tuple__188 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_val, __pyx_n_s_v); if (unlikely(!__pyx_tuple__188)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5631; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__188);
- __Pyx_GIVEREF(__pyx_tuple__188);
- __pyx_codeobj__189 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__188, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_set_auto_maskandscale, 5631, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__189)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5631; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__183 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_val, __pyx_n_s_v); if (unlikely(!__pyx_tuple__183)) __PYX_ERR(0, 5631, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__183);
+ __Pyx_GIVEREF(__pyx_tuple__183);
+ __pyx_codeobj__184 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__183, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_set_auto_maskandscale, 5631, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__184)) __PYX_ERR(0, 5631, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5634
* for v in self._recVar:
@@ -76152,10 +75331,10 @@ static int __Pyx_InitCachedConstants(void) {
* """Get records from a concatenated set of variables."""
*
*/
- __pyx_tuple__190 = PyTuple_Pack(30, __pyx_n_s_self, __pyx_n_s_elem, __pyx_n_s_start, __pyx_n_s_count, __pyx_n_s_stride, __pyx_n_s_put_ind, __pyx_n_s_datashape, __pyx_n_s_data, __pyx_n_s_squeeze, __pyx_n_s_i, __pyx_n_s_n, __pyx_n_s_strt, __pyx_n_s_cnt, __pyx_n_s_strd, __pyx_n_s_nv, __pyx_n_s_ind, __pyx_n_s_sta, __pyx_n_s_step, __pyx_n_s_stop, __pyx_n_s_idx, __pyx_n_s_vid, __pyx_n_s_k, __pyx_n_s_lst, __pyx_n_s_newSlice, __pyx_n_s_s_2, __pyx_n_s_lstArr, __pyx_n_s_ismasked, __pyx_n_s_dat, [...]
- __Pyx_GOTREF(__pyx_tuple__190);
- __Pyx_GIVEREF(__pyx_tuple__190);
- __pyx_codeobj__191 = (PyObject*)__Pyx_PyCode_New(2, 0, 30, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__190, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_getitem, 5634, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__191)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5634; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__185 = PyTuple_Pack(30, __pyx_n_s_self, __pyx_n_s_elem, __pyx_n_s_start, __pyx_n_s_count, __pyx_n_s_stride, __pyx_n_s_put_ind, __pyx_n_s_datashape, __pyx_n_s_data, __pyx_n_s_squeeze, __pyx_n_s_i, __pyx_n_s_n, __pyx_n_s_strt, __pyx_n_s_cnt, __pyx_n_s_strd, __pyx_n_s_nv, __pyx_n_s_ind, __pyx_n_s_sta, __pyx_n_s_step, __pyx_n_s_stop, __pyx_n_s_idx, __pyx_n_s_vid, __pyx_n_s_k, __pyx_n_s_lst, __pyx_n_s_newSlice, __pyx_n_s_s_2, __pyx_n_s_lstArr, __pyx_n_s_ismasked, __pyx_n_s_dat, [...]
+ __Pyx_GOTREF(__pyx_tuple__185);
+ __Pyx_GIVEREF(__pyx_tuple__185);
+ __pyx_codeobj__186 = (PyObject*)__Pyx_PyCode_New(2, 0, 30, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__185, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_getitem, 5634, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__186)) __PYX_ERR(0, 5634, __pyx_L1_error)
/* "netCDF4/_netCDF4.pyx":5773
* """
@@ -76164,13 +75343,13 @@ static int __Pyx_InitCachedConstants(void) {
* """
* **`__init__(self, time, units=None)`**
*/
- __pyx_tuple__192 = PyTuple_Pack(15, __pyx_n_s_self, __pyx_n_s_time, __pyx_n_s_units, __pyx_n_s_datetime, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_t, __pyx_n_s_ref_date, __pyx_n_s_ref_num, __pyx_n_s_i0, __pyx_n_s_i1, __pyx_n_s_i, __pyx_n_s_v, __pyx_n_s_n, __pyx_n_s_num); if (unlikely(!__pyx_tuple__192)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__192);
- __Pyx_GIVEREF(__pyx_tuple__192);
- __pyx_codeobj__193 = (PyObject*)__Pyx_PyCode_New(3, 0, 15, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__192, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_init, 5773, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__193)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_tuple__194 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__194)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__194);
- __Pyx_GIVEREF(__pyx_tuple__194);
+ __pyx_tuple__187 = PyTuple_Pack(15, __pyx_n_s_self, __pyx_n_s_time, __pyx_n_s_units, __pyx_n_s_datetime, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_t, __pyx_n_s_ref_date, __pyx_n_s_ref_num, __pyx_n_s_i0, __pyx_n_s_i1, __pyx_n_s_i, __pyx_n_s_v, __pyx_n_s_n, __pyx_n_s_num); if (unlikely(!__pyx_tuple__187)) __PYX_ERR(0, 5773, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__187);
+ __Pyx_GIVEREF(__pyx_tuple__187);
+ __pyx_codeobj__188 = (PyObject*)__Pyx_PyCode_New(3, 0, 15, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__187, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_init, 5773, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__188)) __PYX_ERR(0, 5773, __pyx_L1_error)
+ __pyx_tuple__189 = PyTuple_Pack(1, ((PyObject *)Py_None)); if (unlikely(!__pyx_tuple__189)) __PYX_ERR(0, 5773, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__189);
+ __Pyx_GIVEREF(__pyx_tuple__189);
/* "netCDF4/_netCDF4.pyx":5821
*
@@ -76178,10 +75357,10 @@ static int __Pyx_InitCachedConstants(void) {
* def __getitem__(self, elem): # <<<<<<<<<<<<<<
* return self.__time[elem] + self.__delta[elem]
*/
- __pyx_tuple__195 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_elem); if (unlikely(!__pyx_tuple__195)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5821; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_tuple__195);
- __Pyx_GIVEREF(__pyx_tuple__195);
- __pyx_codeobj__196 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__195, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_jwhitaker_python_netcdf4, __pyx_n_s_getitem, 5821, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__196)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5821; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_tuple__190 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_elem); if (unlikely(!__pyx_tuple__190)) __PYX_ERR(0, 5821, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_tuple__190);
+ __Pyx_GIVEREF(__pyx_tuple__190);
+ __pyx_codeobj__191 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__190, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_private_tmp_netcdf4_python_netC, __pyx_n_s_getitem, 5821, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__191)) __PYX_ERR(0, 5821, __pyx_L1_error)
__Pyx_RefNannyFinishContext();
return 0;
__pyx_L1_error:;
@@ -76192,31 +75371,32 @@ static int __Pyx_InitCachedConstants(void) {
static int __Pyx_InitGlobals(void) {
__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type;
__pyx_umethod_PyDict_Type_keys.type = (PyObject*)&PyDict_Type;
- if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __pyx_float_0_0 = PyFloat_FromDouble(0.0); if (unlikely(!__pyx_float_0_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_float_1_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_float_24_ = PyFloat_FromDouble(24.); if (unlikely(!__pyx_float_24_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_float_60_ = PyFloat_FromDouble(60.); if (unlikely(!__pyx_float_60_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_float_1_e3 = PyFloat_FromDouble(1.e3); if (unlikely(!__pyx_float_1_e3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_float_1_e6 = PyFloat_FromDouble(1.e6); if (unlikely(!__pyx_float_1_e6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_float_1440_ = PyFloat_FromDouble(1440.); if (unlikely(!__pyx_float_1440_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_float_3600_ = PyFloat_FromDouble(3600.); if (unlikely(!__pyx_float_3600_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_float_86400_ = PyFloat_FromDouble(86400.); if (unlikely(!__pyx_float_86400_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_8 = PyInt_FromLong(8); if (unlikely(!__pyx_int_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_15 = PyInt_FromLong(15); if (unlikely(!__pyx_int_15)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_24 = PyInt_FromLong(24); if (unlikely(!__pyx_int_24)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_60 = PyInt_FromLong(60); if (unlikely(!__pyx_int_60)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_1582 = PyInt_FromLong(1582); if (unlikely(!__pyx_int_1582)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_1900 = PyInt_FromLong(1900); if (unlikely(!__pyx_int_1900)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_3600 = PyInt_FromLong(3600); if (unlikely(!__pyx_int_3600)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
+ __pyx_float_0_0 = PyFloat_FromDouble(0.0); if (unlikely(!__pyx_float_0_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_float_1_0 = PyFloat_FromDouble(1.0); if (unlikely(!__pyx_float_1_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_float_24_ = PyFloat_FromDouble(24.); if (unlikely(!__pyx_float_24_)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_float_60_ = PyFloat_FromDouble(60.); if (unlikely(!__pyx_float_60_)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_float_1_e3 = PyFloat_FromDouble(1.e3); if (unlikely(!__pyx_float_1_e3)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_float_1_e6 = PyFloat_FromDouble(1.e6); if (unlikely(!__pyx_float_1_e6)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_float_1440_ = PyFloat_FromDouble(1440.); if (unlikely(!__pyx_float_1440_)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_float_3600_ = PyFloat_FromDouble(3600.); if (unlikely(!__pyx_float_3600_)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_float_86400_ = PyFloat_FromDouble(86400.); if (unlikely(!__pyx_float_86400_)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_8 = PyInt_FromLong(8); if (unlikely(!__pyx_int_8)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_15 = PyInt_FromLong(15); if (unlikely(!__pyx_int_15)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_24 = PyInt_FromLong(24); if (unlikely(!__pyx_int_24)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_60 = PyInt_FromLong(60); if (unlikely(!__pyx_int_60)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_1582 = PyInt_FromLong(1582); if (unlikely(!__pyx_int_1582)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_1900 = PyInt_FromLong(1900); if (unlikely(!__pyx_int_1900)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_3600 = PyInt_FromLong(3600); if (unlikely(!__pyx_int_3600)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error)
return 0;
__pyx_L1_error:;
return -1;
@@ -76245,12 +75425,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
PyObject *__pyx_t_13 = NULL;
PyObject *__pyx_t_14 = NULL;
int __pyx_t_15;
- Py_ssize_t __pyx_t_16;
- PyObject *(*__pyx_t_17)(PyObject *);
+ int __pyx_t_16;
+ Py_ssize_t __pyx_t_17;
PyObject *(*__pyx_t_18)(PyObject *);
- int __pyx_lineno = 0;
- const char *__pyx_filename = NULL;
- int __pyx_clineno = 0;
+ PyObject *(*__pyx_t_19)(PyObject *);
__Pyx_RefNannyDeclarations
#if CYTHON_REFNANNY
__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
@@ -76262,23 +75440,24 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
#endif
__Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__netCDF4(void)", 0);
- if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
#ifdef __Pyx_CyFunction_USED
- if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_FusedFunction_USED
- if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_Coroutine_USED
- if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_Generator_USED
- if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
#ifdef __Pyx_StopAsyncIteration_USED
- if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
/*--- Library function declarations ---*/
/*--- Threads initialization code ---*/
@@ -76289,48 +75468,48 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
#endif
/*--- Module creation code ---*/
#if PY_MAJOR_VERSION < 3
- __pyx_m = Py_InitModule4("_netCDF4", __pyx_methods, __pyx_k_Version_1_2_3_Introduction_netc, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
+ __pyx_m = Py_InitModule4("_netCDF4", __pyx_methods, __pyx_k_Version_1_2_4_Introduction_netc, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
#else
__pyx_m = PyModule_Create(&__pyx_moduledef);
#endif
- if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
Py_INCREF(__pyx_d);
- __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
#if CYTHON_COMPILING_IN_PYPY
Py_INCREF(__pyx_b);
#endif
- if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
/*--- Initialize various global constants etc. ---*/
- if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
- if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
if (__pyx_module_is_main_netCDF4___netCDF4) {
- if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
}
#if PY_MAJOR_VERSION >= 3
{
- PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
if (!PyDict_GetItemString(modules, "netCDF4._netCDF4")) {
- if (unlikely(PyDict_SetItemString(modules, "netCDF4._netCDF4", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyDict_SetItemString(modules, "netCDF4._netCDF4", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
}
}
#endif
/*--- Builtin init code ---*/
- if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
/*--- Constants init code ---*/
- if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
/*--- Global init code ---*/
/*--- Variable export code ---*/
/*--- Function export code ---*/
/*--- Type init code ---*/
- __pyx_ptype_7netCDF4_8_netCDF4_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_7netCDF4_8_netCDF4_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 723; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_Dataset) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1545; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_ptype_7netCDF4_8_netCDF4_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_7netCDF4_8_netCDF4_ndarray)) __PYX_ERR(1, 723, __pyx_L1_error)
+ if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_Dataset) < 0) __PYX_ERR(0, 1555, __pyx_L1_error)
__pyx_type_7netCDF4_8_netCDF4_Dataset.tp_print = 0;
#if CYTHON_COMPILING_IN_CPYTHON
{
- PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Dataset, "__init__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1545; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Dataset, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 1555, __pyx_L1_error)
if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {
__pyx_wrapperbase_7netCDF4_8_netCDF4_7Dataset___init__ = *((PyWrapperDescrObject *)wrapper)->d_base;
__pyx_wrapperbase_7netCDF4_8_netCDF4_7Dataset___init__.doc = __pyx_doc_7netCDF4_8_netCDF4_7Dataset___init__;
@@ -76338,15 +75517,15 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
#endif
- if (PyObject_SetAttrString(__pyx_m, "Dataset", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Dataset) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1545; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyObject_SetAttrString(__pyx_m, "Dataset", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Dataset) < 0) __PYX_ERR(0, 1555, __pyx_L1_error)
if (__pyx_type_7netCDF4_8_netCDF4_Dataset.tp_weaklistoffset == 0) __pyx_type_7netCDF4_8_netCDF4_Dataset.tp_weaklistoffset = offsetof(struct __pyx_obj_7netCDF4_8_netCDF4_Dataset, __weakref__);
__pyx_ptype_7netCDF4_8_netCDF4_Dataset = &__pyx_type_7netCDF4_8_netCDF4_Dataset;
__pyx_type_7netCDF4_8_netCDF4_Group.tp_base = __pyx_ptype_7netCDF4_8_netCDF4_Dataset;
- if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_Group) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_Group) < 0) __PYX_ERR(0, 2550, __pyx_L1_error)
__pyx_type_7netCDF4_8_netCDF4_Group.tp_print = 0;
#if CYTHON_COMPILING_IN_CPYTHON
{
- PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Group, "__init__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Group, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 2550, __pyx_L1_error)
if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {
__pyx_wrapperbase_7netCDF4_8_netCDF4_5Group___init__ = *((PyWrapperDescrObject *)wrapper)->d_base;
__pyx_wrapperbase_7netCDF4_8_netCDF4_5Group___init__.doc = __pyx_doc_7netCDF4_8_netCDF4_5Group___init__;
@@ -76354,14 +75533,14 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
#endif
- if (PyObject_SetAttrString(__pyx_m, "Group", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Group) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyObject_SetAttrString(__pyx_m, "Group", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Group) < 0) __PYX_ERR(0, 2550, __pyx_L1_error)
if (__pyx_type_7netCDF4_8_netCDF4_Group.tp_weaklistoffset == 0) __pyx_type_7netCDF4_8_netCDF4_Group.tp_weaklistoffset = offsetof(struct __pyx_obj_7netCDF4_8_netCDF4_Group, __pyx_base.__weakref__);
__pyx_ptype_7netCDF4_8_netCDF4_Group = &__pyx_type_7netCDF4_8_netCDF4_Group;
- if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_Dimension) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2635; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_Dimension) < 0) __PYX_ERR(0, 2645, __pyx_L1_error)
__pyx_type_7netCDF4_8_netCDF4_Dimension.tp_print = 0;
#if CYTHON_COMPILING_IN_CPYTHON
{
- PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Dimension, "__init__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2635; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Dimension, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 2645, __pyx_L1_error)
if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {
__pyx_wrapperbase_7netCDF4_8_netCDF4_9Dimension___init__ = *((PyWrapperDescrObject *)wrapper)->d_base;
__pyx_wrapperbase_7netCDF4_8_netCDF4_9Dimension___init__.doc = __pyx_doc_7netCDF4_8_netCDF4_9Dimension___init__;
@@ -76369,13 +75548,13 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
#endif
- if (PyObject_SetAttrString(__pyx_m, "Dimension", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Dimension) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2635; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyObject_SetAttrString(__pyx_m, "Dimension", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Dimension) < 0) __PYX_ERR(0, 2645, __pyx_L1_error)
__pyx_ptype_7netCDF4_8_netCDF4_Dimension = &__pyx_type_7netCDF4_8_netCDF4_Dimension;
- if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_Variable) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2796; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_Variable) < 0) __PYX_ERR(0, 2806, __pyx_L1_error)
__pyx_type_7netCDF4_8_netCDF4_Variable.tp_print = 0;
#if CYTHON_COMPILING_IN_CPYTHON
{
- PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Variable, "__init__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2796; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Variable, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 2806, __pyx_L1_error)
if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {
__pyx_wrapperbase_7netCDF4_8_netCDF4_8Variable___init__ = *((PyWrapperDescrObject *)wrapper)->d_base;
__pyx_wrapperbase_7netCDF4_8_netCDF4_8Variable___init__.doc = __pyx_doc_7netCDF4_8_netCDF4_8Variable___init__;
@@ -76383,13 +75562,13 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
#endif
- if (PyObject_SetAttrString(__pyx_m, "Variable", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Variable) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2796; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyObject_SetAttrString(__pyx_m, "Variable", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_Variable) < 0) __PYX_ERR(0, 2806, __pyx_L1_error)
__pyx_ptype_7netCDF4_8_netCDF4_Variable = &__pyx_type_7netCDF4_8_netCDF4_Variable;
- if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_CompoundType) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_CompoundType) < 0) __PYX_ERR(0, 4465, __pyx_L1_error)
__pyx_type_7netCDF4_8_netCDF4_CompoundType.tp_print = 0;
#if CYTHON_COMPILING_IN_CPYTHON
{
- PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_CompoundType, "__init__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_CompoundType, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 4465, __pyx_L1_error)
if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {
__pyx_wrapperbase_7netCDF4_8_netCDF4_12CompoundType___init__ = *((PyWrapperDescrObject *)wrapper)->d_base;
__pyx_wrapperbase_7netCDF4_8_netCDF4_12CompoundType___init__.doc = __pyx_doc_7netCDF4_8_netCDF4_12CompoundType___init__;
@@ -76397,13 +75576,13 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
#endif
- if (PyObject_SetAttrString(__pyx_m, "CompoundType", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_CompoundType) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4465; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyObject_SetAttrString(__pyx_m, "CompoundType", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_CompoundType) < 0) __PYX_ERR(0, 4465, __pyx_L1_error)
__pyx_ptype_7netCDF4_8_netCDF4_CompoundType = &__pyx_type_7netCDF4_8_netCDF4_CompoundType;
- if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_VLType) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_VLType) < 0) __PYX_ERR(0, 4710, __pyx_L1_error)
__pyx_type_7netCDF4_8_netCDF4_VLType.tp_print = 0;
#if CYTHON_COMPILING_IN_CPYTHON
{
- PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_VLType, "__init__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_VLType, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 4710, __pyx_L1_error)
if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {
__pyx_wrapperbase_7netCDF4_8_netCDF4_6VLType___init__ = *((PyWrapperDescrObject *)wrapper)->d_base;
__pyx_wrapperbase_7netCDF4_8_netCDF4_6VLType___init__.doc = __pyx_doc_7netCDF4_8_netCDF4_6VLType___init__;
@@ -76411,13 +75590,13 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
#endif
- if (PyObject_SetAttrString(__pyx_m, "VLType", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_VLType) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4710; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyObject_SetAttrString(__pyx_m, "VLType", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_VLType) < 0) __PYX_ERR(0, 4710, __pyx_L1_error)
__pyx_ptype_7netCDF4_8_netCDF4_VLType = &__pyx_type_7netCDF4_8_netCDF4_VLType;
- if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_EnumType) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4824; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4_EnumType) < 0) __PYX_ERR(0, 4824, __pyx_L1_error)
__pyx_type_7netCDF4_8_netCDF4_EnumType.tp_print = 0;
#if CYTHON_COMPILING_IN_CPYTHON
{
- PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_EnumType, "__init__"); if (unlikely(!wrapper)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4824; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyObject *wrapper = PyObject_GetAttrString((PyObject *)&__pyx_type_7netCDF4_8_netCDF4_EnumType, "__init__"); if (unlikely(!wrapper)) __PYX_ERR(0, 4824, __pyx_L1_error)
if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {
__pyx_wrapperbase_7netCDF4_8_netCDF4_8EnumType___init__ = *((PyWrapperDescrObject *)wrapper)->d_base;
__pyx_wrapperbase_7netCDF4_8_netCDF4_8EnumType___init__.doc = __pyx_doc_7netCDF4_8_netCDF4_8EnumType___init__;
@@ -76425,9 +75604,9 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
#endif
- if (PyObject_SetAttrString(__pyx_m, "EnumType", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_EnumType) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4824; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyObject_SetAttrString(__pyx_m, "EnumType", (PyObject *)&__pyx_type_7netCDF4_8_netCDF4_EnumType) < 0) __PYX_ERR(0, 4824, __pyx_L1_error)
__pyx_ptype_7netCDF4_8_netCDF4_EnumType = &__pyx_type_7netCDF4_8_netCDF4_EnumType;
- if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyType_Ready(&__pyx_type_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr) < 0) __PYX_ERR(0, 1031, __pyx_L1_error)
__pyx_type_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr.tp_print = 0;
__pyx_ptype_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr = &__pyx_type_7netCDF4_8_netCDF4___pyx_scope_struct__genexpr;
/*--- Type import code ---*/
@@ -76435,17 +75614,17 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
/*--- Function import code ---*/
/*--- Execution code ---*/
#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
- if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
#endif
- /* "netCDF4/_netCDF4.pyx":919
+ /* "netCDF4/_netCDF4.pyx":922
*
* # pure python utilities
* from .utils import (_StartCountStride, _quantize, _find_dim, _walk_grps, # <<<<<<<<<<<<<<
* _out_array_shape, _sortbylist, _tostr)
* # try to use built-in ordered dict in python >= 2.7
*/
- __pyx_t_1 = PyList_New(7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_n_s_StartCountStride);
__Pyx_GIVEREF(__pyx_n_s_StartCountStride);
@@ -76468,40 +75647,40 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
__Pyx_INCREF(__pyx_n_s_tostr);
__Pyx_GIVEREF(__pyx_n_s_tostr);
PyList_SET_ITEM(__pyx_t_1, 6, __pyx_n_s_tostr);
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_utils, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_utils, __pyx_t_1, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_StartCountStride); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_StartCountStride); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_StartCountStride, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_StartCountStride, __pyx_t_1) < 0) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_quantize); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_quantize); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_quantize, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_quantize, __pyx_t_1) < 0) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_find_dim); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_find_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_dim, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_find_dim, __pyx_t_1) < 0) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_walk_grps); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_walk_grps); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_walk_grps, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_walk_grps, __pyx_t_1) < 0) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_out_array_shape); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_out_array_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_out_array_shape, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_out_array_shape, __pyx_t_1) < 0) __PYX_ERR(0, 923, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_sortbylist); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_sortbylist); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_sortbylist, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_sortbylist, __pyx_t_1) < 0) __PYX_ERR(0, 923, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_tostr); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_tostr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_tostr, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_tostr, __pyx_t_1) < 0) __PYX_ERR(0, 923, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":922
+ /* "netCDF4/_netCDF4.pyx":925
* _out_array_shape, _sortbylist, _tostr)
* # try to use built-in ordered dict in python >= 2.7
* try: # <<<<<<<<<<<<<<
@@ -76509,34 +75688,36 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* except ImportError: # or else use drop-in substitute
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_5);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":923
+ /* "netCDF4/_netCDF4.pyx":926
* # try to use built-in ordered dict in python >= 2.7
* try:
* from collections import OrderedDict # <<<<<<<<<<<<<<
* except ImportError: # or else use drop-in substitute
* try:
*/
- __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L2_error;}
+ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 926, __pyx_L2_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_OrderedDict);
__Pyx_GIVEREF(__pyx_n_s_OrderedDict);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_OrderedDict);
- __pyx_t_1 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L2_error;}
+ __pyx_t_1 = __Pyx_Import(__pyx_n_s_collections, __pyx_t_2, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 926, __pyx_L2_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L2_error;}
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 926, __pyx_L2_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 923; __pyx_clineno = __LINE__; goto __pyx_L2_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_2) < 0) __PYX_ERR(0, 926, __pyx_L2_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":922
+ /* "netCDF4/_netCDF4.pyx":925
* _out_array_shape, _sortbylist, _tostr)
* # try to use built-in ordered dict in python >= 2.7
* try: # <<<<<<<<<<<<<<
@@ -76549,25 +75730,26 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
goto __pyx_L9_try_end;
__pyx_L2_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":924
+ /* "netCDF4/_netCDF4.pyx":927
* try:
* from collections import OrderedDict
* except ImportError: # or else use drop-in substitute # <<<<<<<<<<<<<<
* try:
* from ordereddict import OrderedDict
*/
- __pyx_t_6 = PyErr_ExceptionMatches(__pyx_builtin_ImportError);
+ __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
if (__pyx_t_6) {
__Pyx_AddTraceback("netCDF4._netCDF4", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 924; __pyx_clineno = __LINE__; goto __pyx_L4_except_error;}
+ if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_7) < 0) __PYX_ERR(0, 927, __pyx_L4_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_7);
- /* "netCDF4/_netCDF4.pyx":925
+ /* "netCDF4/_netCDF4.pyx":928
* from collections import OrderedDict
* except ImportError: # or else use drop-in substitute
* try: # <<<<<<<<<<<<<<
@@ -76575,34 +75757,36 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* except ImportError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_10);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":926
+ /* "netCDF4/_netCDF4.pyx":929
* except ImportError: # or else use drop-in substitute
* try:
* from ordereddict import OrderedDict # <<<<<<<<<<<<<<
* except ImportError:
* raise ImportError('please install ordereddict (https://pypi.python.org/pypi/ordereddict)')
*/
- __pyx_t_11 = PyList_New(1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L12_error;}
+ __pyx_t_11 = PyList_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 929, __pyx_L12_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_INCREF(__pyx_n_s_OrderedDict);
__Pyx_GIVEREF(__pyx_n_s_OrderedDict);
PyList_SET_ITEM(__pyx_t_11, 0, __pyx_n_s_OrderedDict);
- __pyx_t_12 = __Pyx_Import(__pyx_n_s_ordereddict, __pyx_t_11, -1); if (unlikely(!__pyx_t_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L12_error;}
+ __pyx_t_12 = __Pyx_Import(__pyx_n_s_ordereddict, __pyx_t_11, -1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 929, __pyx_L12_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __pyx_t_11 = __Pyx_ImportFrom(__pyx_t_12, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L12_error;}
+ __pyx_t_11 = __Pyx_ImportFrom(__pyx_t_12, __pyx_n_s_OrderedDict); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 929, __pyx_L12_error)
__Pyx_GOTREF(__pyx_t_11);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_11) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L12_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_OrderedDict, __pyx_t_11) < 0) __PYX_ERR(0, 929, __pyx_L12_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
- /* "netCDF4/_netCDF4.pyx":925
+ /* "netCDF4/_netCDF4.pyx":928
* from collections import OrderedDict
* except ImportError: # or else use drop-in substitute
* try: # <<<<<<<<<<<<<<
@@ -76615,47 +75799,49 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
goto __pyx_L19_try_end;
__pyx_L12_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
- /* "netCDF4/_netCDF4.pyx":927
+ /* "netCDF4/_netCDF4.pyx":930
* try:
* from ordereddict import OrderedDict
* except ImportError: # <<<<<<<<<<<<<<
* raise ImportError('please install ordereddict (https://pypi.python.org/pypi/ordereddict)')
* try:
*/
- __pyx_t_6 = PyErr_ExceptionMatches(__pyx_builtin_ImportError);
+ __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
if (__pyx_t_6) {
__Pyx_AddTraceback("netCDF4._netCDF4", __pyx_clineno, __pyx_lineno, __pyx_filename);
- if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_11, &__pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 927; __pyx_clineno = __LINE__; goto __pyx_L14_except_error;}
+ if (__Pyx_GetException(&__pyx_t_12, &__pyx_t_11, &__pyx_t_13) < 0) __PYX_ERR(0, 930, __pyx_L14_except_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GOTREF(__pyx_t_13);
- /* "netCDF4/_netCDF4.pyx":928
+ /* "netCDF4/_netCDF4.pyx":931
* from ordereddict import OrderedDict
* except ImportError:
* raise ImportError('please install ordereddict (https://pypi.python.org/pypi/ordereddict)') # <<<<<<<<<<<<<<
* try:
* from itertools import izip as zip
*/
- __pyx_t_14 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__128, NULL); if (unlikely(!__pyx_t_14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; __pyx_clineno = __LINE__; goto __pyx_L14_except_error;}
+ __pyx_t_14 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__121, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 931, __pyx_L14_except_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_Raise(__pyx_t_14, 0, 0, 0);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 928; __pyx_clineno = __LINE__; goto __pyx_L14_except_error;}
+ __PYX_ERR(0, 931, __pyx_L14_except_error)
}
goto __pyx_L14_except_error;
__pyx_L14_except_error:;
- /* "netCDF4/_netCDF4.pyx":925
+ /* "netCDF4/_netCDF4.pyx":928
* from collections import OrderedDict
* except ImportError: # or else use drop-in substitute
* try: # <<<<<<<<<<<<<<
* from ordereddict import OrderedDict
* except ImportError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
@@ -76671,19 +75857,21 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
goto __pyx_L4_except_error;
__pyx_L4_except_error:;
- /* "netCDF4/_netCDF4.pyx":922
+ /* "netCDF4/_netCDF4.pyx":925
* _out_array_shape, _sortbylist, _tostr)
* # try to use built-in ordered dict in python >= 2.7
* try: # <<<<<<<<<<<<<<
* from collections import OrderedDict
* except ImportError: # or else use drop-in substitute
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
goto __pyx_L1_error;
__pyx_L3_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
@@ -76691,7 +75879,7 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
__pyx_L9_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":929
+ /* "netCDF4/_netCDF4.pyx":932
* except ImportError:
* raise ImportError('please install ordereddict (https://pypi.python.org/pypi/ordereddict)')
* try: # <<<<<<<<<<<<<<
@@ -76699,34 +75887,36 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* except ImportError:
*/
{
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
- /* "netCDF4/_netCDF4.pyx":930
+ /* "netCDF4/_netCDF4.pyx":933
* raise ImportError('please install ordereddict (https://pypi.python.org/pypi/ordereddict)')
* try:
* from itertools import izip as zip # <<<<<<<<<<<<<<
* except ImportError:
* # python3: zip is already python2's itertools.izip
*/
- __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L22_error;}
+ __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 933, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_n_s_izip);
__Pyx_GIVEREF(__pyx_n_s_izip);
PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_izip);
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_itertools, __pyx_t_7, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L22_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_itertools, __pyx_t_7, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 933, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_izip); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L22_error;}
+ __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_izip); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 933, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_zip, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 930; __pyx_clineno = __LINE__; goto __pyx_L22_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_zip, __pyx_t_7) < 0) __PYX_ERR(0, 933, __pyx_L22_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":929
+ /* "netCDF4/_netCDF4.pyx":932
* except ImportError:
* raise ImportError('please install ordereddict (https://pypi.python.org/pypi/ordereddict)')
* try: # <<<<<<<<<<<<<<
@@ -76739,6 +75929,7 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L29_try_end;
__pyx_L22_error:;
+ __Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
@@ -76747,34 +75938,36 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":931
+ /* "netCDF4/_netCDF4.pyx":934
* try:
* from itertools import izip as zip
* except ImportError: # <<<<<<<<<<<<<<
* # python3: zip is already python2's itertools.izip
* pass
*/
- __pyx_t_6 = PyErr_ExceptionMatches(__pyx_builtin_ImportError);
+ __pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ImportError);
if (__pyx_t_6) {
- PyErr_Restore(0,0,0);
+ __Pyx_ErrRestore(0,0,0);
goto __pyx_L23_exception_handled;
}
goto __pyx_L24_except_error;
__pyx_L24_except_error:;
- /* "netCDF4/_netCDF4.pyx":929
+ /* "netCDF4/_netCDF4.pyx":932
* except ImportError:
* raise ImportError('please install ordereddict (https://pypi.python.org/pypi/ordereddict)')
* try: # <<<<<<<<<<<<<<
* from itertools import izip as zip
* except ImportError:
*/
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3);
goto __pyx_L1_error;
__pyx_L23_exception_handled:;
+ __Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_3);
@@ -76782,130 +75975,130 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
__pyx_L29_try_end:;
}
- /* "netCDF4/_netCDF4.pyx":935
+ /* "netCDF4/_netCDF4.pyx":938
* pass
*
- * __version__ = "1.2.3" # <<<<<<<<<<<<<<
+ * __version__ = "1.2.4" # <<<<<<<<<<<<<<
*
* # Initialize numpy
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_kp_s_1_2_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_kp_s_1_2_4) < 0) __PYX_ERR(0, 938, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":938
+ /* "netCDF4/_netCDF4.pyx":941
*
* # Initialize numpy
* import posixpath # <<<<<<<<<<<<<<
* import netcdftime
* import numpy
*/
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_posixpath, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 938; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_posixpath, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 941, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_posixpath, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 938; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_posixpath, __pyx_t_2) < 0) __PYX_ERR(0, 941, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":939
+ /* "netCDF4/_netCDF4.pyx":942
* # Initialize numpy
* import posixpath
* import netcdftime # <<<<<<<<<<<<<<
* import numpy
* import weakref
*/
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_netcdftime, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_netcdftime, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 942, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_netcdftime, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 939; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_netcdftime, __pyx_t_2) < 0) __PYX_ERR(0, 942, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":940
+ /* "netCDF4/_netCDF4.pyx":943
* import posixpath
* import netcdftime
* import numpy # <<<<<<<<<<<<<<
* import weakref
* import sys
*/
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 940; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 943, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 940; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_numpy, __pyx_t_2) < 0) __PYX_ERR(0, 943, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":941
+ /* "netCDF4/_netCDF4.pyx":944
* import netcdftime
* import numpy
* import weakref # <<<<<<<<<<<<<<
* import sys
* import warnings
*/
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_weakref, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_weakref, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 944, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_weakref, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_weakref, __pyx_t_2) < 0) __PYX_ERR(0, 944, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":942
+ /* "netCDF4/_netCDF4.pyx":945
* import numpy
* import weakref
* import sys # <<<<<<<<<<<<<<
* import warnings
* from glob import glob
*/
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 942; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_sys, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 942; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_2) < 0) __PYX_ERR(0, 945, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":943
+ /* "netCDF4/_netCDF4.pyx":946
* import weakref
* import sys
* import warnings # <<<<<<<<<<<<<<
* from glob import glob
* from numpy import ma
*/
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_warnings, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 943; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_warnings, 0, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_warnings, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 943; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_warnings, __pyx_t_2) < 0) __PYX_ERR(0, 946, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":944
+ /* "netCDF4/_netCDF4.pyx":947
* import sys
* import warnings
* from glob import glob # <<<<<<<<<<<<<<
* from numpy import ma
* from libc.string cimport memcpy
*/
- __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 947, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_glob);
__Pyx_GIVEREF(__pyx_n_s_glob);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_glob);
- __pyx_t_7 = __Pyx_Import(__pyx_n_s_glob, __pyx_t_2, -1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_Import(__pyx_n_s_glob, __pyx_t_2, -1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 947, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_7, __pyx_n_s_glob); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_7, __pyx_n_s_glob); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 947, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_glob, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_glob, __pyx_t_2) < 0) __PYX_ERR(0, 947, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- /* "netCDF4/_netCDF4.pyx":945
+ /* "netCDF4/_netCDF4.pyx":948
* import warnings
* from glob import glob
* from numpy import ma # <<<<<<<<<<<<<<
* from libc.string cimport memcpy
* from libc.stdlib cimport malloc, free
*/
- __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyList_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_n_s_ma);
__Pyx_GIVEREF(__pyx_n_s_ma);
PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_ma);
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, __pyx_t_7, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, __pyx_t_7, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ma); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_ma); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_ma, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_ma, __pyx_t_7) < 0) __PYX_ERR(0, 948, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":948
+ /* "netCDF4/_netCDF4.pyx":951
* from libc.string cimport memcpy
* from libc.stdlib cimport malloc, free
* import_array() # <<<<<<<<<<<<<<
@@ -76914,38 +76107,38 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
*/
import_array();
- /* "netCDF4/_netCDF4.pyx":954
+ /* "netCDF4/_netCDF4.pyx":957
* # check for required version of netcdf-4 and hdf5.
*
* def _gethdf5libversion(): # <<<<<<<<<<<<<<
* majorvers = H5_VERS_MAJOR
* minorvers = H5_VERS_MINOR
*/
- __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_1_gethdf5libversion, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_1_gethdf5libversion, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 957, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_gethdf5libversion, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 954; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_gethdf5libversion, __pyx_t_2) < 0) __PYX_ERR(0, 957, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":964
+ /* "netCDF4/_netCDF4.pyx":967
* return '%d.%d.%d-%s' % (majorvers,minorvers,releasevers,patchstring)
*
* def getlibversion(): # <<<<<<<<<<<<<<
* """
* **`getlibversion()`**
*/
- __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_3getlibversion, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_3getlibversion, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 967, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_getlibversion, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 964; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_getlibversion, __pyx_t_2) < 0) __PYX_ERR(0, 967, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":973
+ /* "netCDF4/_netCDF4.pyx":976
* return (<char *>nc_inq_libvers()).decode('ascii')
*
* __netcdf4libversion__ = getlibversion().split()[0] # <<<<<<<<<<<<<<
* __hdf5libversion__ = _gethdf5libversion()
* __has_rename_grp__ = HAS_RENAME_GRP
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_getlibversion); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_getlibversion); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 976, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_13 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_1))) {
@@ -76958,14 +76151,14 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
if (__pyx_t_13) {
- __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_13); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 976, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
} else {
- __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 976, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 976, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = NULL;
@@ -76979,27 +76172,27 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
if (__pyx_t_7) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 976, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 976, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
+ __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 976, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_netcdf4libversion, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 973; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_netcdf4libversion, __pyx_t_1) < 0) __PYX_ERR(0, 976, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":974
+ /* "netCDF4/_netCDF4.pyx":977
*
* __netcdf4libversion__ = getlibversion().split()[0]
* __hdf5libversion__ = _gethdf5libversion() # <<<<<<<<<<<<<<
* __has_rename_grp__ = HAS_RENAME_GRP
* __has_nc_inq_path__ = HAS_NC_INQ_PATH
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_gethdf5libversion); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_gethdf5libversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 977, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_7 = NULL;
if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
@@ -77012,64 +76205,64 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
}
if (__pyx_t_7) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 977, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 977, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_hdf5libversion, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 974; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_hdf5libversion, __pyx_t_1) < 0) __PYX_ERR(0, 977, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":975
+ /* "netCDF4/_netCDF4.pyx":978
* __netcdf4libversion__ = getlibversion().split()[0]
* __hdf5libversion__ = _gethdf5libversion()
* __has_rename_grp__ = HAS_RENAME_GRP # <<<<<<<<<<<<<<
* __has_nc_inq_path__ = HAS_NC_INQ_PATH
* __has_nc_inq_format_extended__ = HAS_NC_INQ_FORMAT_EXTENDED
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_has_rename_grp, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_has_rename_grp, __pyx_int_0) < 0) __PYX_ERR(0, 978, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":976
+ /* "netCDF4/_netCDF4.pyx":979
* __hdf5libversion__ = _gethdf5libversion()
* __has_rename_grp__ = HAS_RENAME_GRP
* __has_nc_inq_path__ = HAS_NC_INQ_PATH # <<<<<<<<<<<<<<
* __has_nc_inq_format_extended__ = HAS_NC_INQ_FORMAT_EXTENDED
* __has_cdf5__ = HAS_CDF5_FORMAT
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_has_nc_inq_path, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 976; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_has_nc_inq_path, __pyx_int_0) < 0) __PYX_ERR(0, 979, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":977
+ /* "netCDF4/_netCDF4.pyx":980
* __has_rename_grp__ = HAS_RENAME_GRP
* __has_nc_inq_path__ = HAS_NC_INQ_PATH
* __has_nc_inq_format_extended__ = HAS_NC_INQ_FORMAT_EXTENDED # <<<<<<<<<<<<<<
* __has_cdf5__ = HAS_CDF5_FORMAT
* _needsworkaround_issue485 = __netcdf4libversion__ < "4.4.0" or \
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_has_nc_inq_format_extended, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_has_nc_inq_format_extended, __pyx_int_0) < 0) __PYX_ERR(0, 980, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":978
+ /* "netCDF4/_netCDF4.pyx":981
* __has_nc_inq_path__ = HAS_NC_INQ_PATH
* __has_nc_inq_format_extended__ = HAS_NC_INQ_FORMAT_EXTENDED
* __has_cdf5__ = HAS_CDF5_FORMAT # <<<<<<<<<<<<<<
* _needsworkaround_issue485 = __netcdf4libversion__ < "4.4.0" or \
* (__netcdf4libversion__.startswith("4.4.0") and \
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_has_cdf5, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 978; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_has_cdf5, __pyx_int_0) < 0) __PYX_ERR(0, 981, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":979
+ /* "netCDF4/_netCDF4.pyx":982
* __has_nc_inq_format_extended__ = HAS_NC_INQ_FORMAT_EXTENDED
* __has_cdf5__ = HAS_CDF5_FORMAT
* _needsworkaround_issue485 = __netcdf4libversion__ < "4.4.0" or \ # <<<<<<<<<<<<<<
* (__netcdf4libversion__.startswith("4.4.0") and \
* "-development" in __netcdf4libversion__)
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 982, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_kp_s_4_4_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = PyObject_RichCompare(__pyx_t_2, __pyx_kp_s_4_4_0, Py_LT); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 982, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_15 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_15 < 0)) __PYX_ERR(0, 982, __pyx_L1_error)
if (!__pyx_t_15) {
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
@@ -77079,22 +76272,22 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
goto __pyx_L30_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":980
+ /* "netCDF4/_netCDF4.pyx":983
* __has_cdf5__ = HAS_CDF5_FORMAT
* _needsworkaround_issue485 = __netcdf4libversion__ < "4.4.0" or \
* (__netcdf4libversion__.startswith("4.4.0") and \ # <<<<<<<<<<<<<<
* "-development" in __netcdf4libversion__)
*
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 983, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_startswith); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_startswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 983, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__132, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__125, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 983, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_15 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 980; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_15 < 0)) __PYX_ERR(0, 983, __pyx_L1_error)
if (__pyx_t_15) {
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
@@ -77104,649 +76297,760 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
goto __pyx_L30_bool_binop_done;
}
- /* "netCDF4/_netCDF4.pyx":981
+ /* "netCDF4/_netCDF4.pyx":984
* _needsworkaround_issue485 = __netcdf4libversion__ < "4.4.0" or \
* (__netcdf4libversion__.startswith("4.4.0") and \
* "-development" in __netcdf4libversion__) # <<<<<<<<<<<<<<
*
- * # numpy data type <--> netCDF 4 data type mapping.
+ * # issue warning for hdf5 1.10 (issue #549)
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_15 = (__Pyx_PySequence_ContainsTF(__pyx_kp_s_development, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_15 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_15 = (__Pyx_PySequence_ContainsTF(__pyx_kp_s_development, __pyx_t_7, Py_EQ)); if (unlikely(__pyx_t_15 < 0)) __PYX_ERR(0, 984, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_t_15); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 981; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_t_15); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_1 = __pyx_t_7;
__pyx_t_7 = 0;
__pyx_L30_bool_binop_done:;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_needsworkaround_issue485, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 979; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_needsworkaround_issue485, __pyx_t_1) < 0) __PYX_ERR(0, 982, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":984
+ /* "netCDF4/_netCDF4.pyx":987
+ *
+ * # issue warning for hdf5 1.10 (issue #549)
+ * if __netcdf4libversion__[0:5] < "4.4.1" and\ # <<<<<<<<<<<<<<
+ * __hdf5libversion__.startswith("1.10"):
+ * msg = """
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_netcdf4libversion); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 987, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_GetSlice(__pyx_t_1, 0, 5, NULL, NULL, &__pyx_slice__126, 1, 1, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 987, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_kp_s_4_4_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 987, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 987, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (__pyx_t_16) {
+ } else {
+ __pyx_t_15 = __pyx_t_16;
+ goto __pyx_L34_bool_binop_done;
+ }
+
+ /* "netCDF4/_netCDF4.pyx":988
+ * # issue warning for hdf5 1.10 (issue #549)
+ * if __netcdf4libversion__[0:5] < "4.4.1" and\
+ * __hdf5libversion__.startswith("1.10"): # <<<<<<<<<<<<<<
+ * msg = """
+ * WARNING: Backwards incompatible files will be created with HDF5 1.10.x
+ */
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_hdf5libversion); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 988, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_startswith); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 988, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_tuple__127, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 988, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_16 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_16 < 0)) __PYX_ERR(0, 988, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_15 = __pyx_t_16;
+ __pyx_L34_bool_binop_done:;
+
+ /* "netCDF4/_netCDF4.pyx":987
+ *
+ * # issue warning for hdf5 1.10 (issue #549)
+ * if __netcdf4libversion__[0:5] < "4.4.1" and\ # <<<<<<<<<<<<<<
+ * __hdf5libversion__.startswith("1.10"):
+ * msg = """
+ */
+ if (__pyx_t_15) {
+
+ /* "netCDF4/_netCDF4.pyx":989
+ * if __netcdf4libversion__[0:5] < "4.4.1" and\
+ * __hdf5libversion__.startswith("1.10"):
+ * msg = """ # <<<<<<<<<<<<<<
+ * WARNING: Backwards incompatible files will be created with HDF5 1.10.x
+ * and netCDF < 4.4.1. Upgrading to netCDF4 >= 4.4.1 or downgrading to
+ */
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_msg, __pyx_kp_s_WARNING_Backwards_incompatible) < 0) __PYX_ERR(0, 989, __pyx_L1_error)
+
+ /* "netCDF4/_netCDF4.pyx":994
+ * to HDF5 version 1.8.x is highly recommended
+ * (see https://github.com/Unidata/netcdf-c/issues/250)."""
+ * warnings.warn(msg) # <<<<<<<<<<<<<<
+ *
+ * # numpy data type <--> netCDF 4 data type mapping.
+ */
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 994, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_warn); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 994, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_msg); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 994, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_13 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_13 = PyMethod_GET_SELF(__pyx_t_2);
+ if (likely(__pyx_t_13)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
+ __Pyx_INCREF(__pyx_t_13);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
+ }
+ }
+ if (!__pyx_t_13) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 994, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_GOTREF(__pyx_t_1);
+ } else {
+ __pyx_t_11 = PyTuple_New(1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 994, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_13); __pyx_t_13 = NULL;
+ __Pyx_GIVEREF(__pyx_t_7);
+ PyTuple_SET_ITEM(__pyx_t_11, 0+1, __pyx_t_7);
+ __pyx_t_7 = 0;
+ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 994, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "netCDF4/_netCDF4.pyx":987
+ *
+ * # issue warning for hdf5 1.10 (issue #549)
+ * if __netcdf4libversion__[0:5] < "4.4.1" and\ # <<<<<<<<<<<<<<
+ * __hdf5libversion__.startswith("1.10"):
+ * msg = """
+ */
+ }
+
+ /* "netCDF4/_netCDF4.pyx":997
*
* # numpy data type <--> netCDF 4 data type mapping.
* _nptonctype = {'S1' : NC_CHAR, # <<<<<<<<<<<<<<
* 'i1' : NC_BYTE,
* 'u1' : NC_UBYTE,
*/
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 997, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_CHAR); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_S1, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_CHAR); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_S1, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":985
+ /* "netCDF4/_netCDF4.pyx":998
* # numpy data type <--> netCDF 4 data type mapping.
* _nptonctype = {'S1' : NC_CHAR,
* 'i1' : NC_BYTE, # <<<<<<<<<<<<<<
* 'u1' : NC_UBYTE,
* 'i2' : NC_SHORT,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_BYTE); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 985; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i1, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_BYTE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 998, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i1, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":986
+ /* "netCDF4/_netCDF4.pyx":999
* _nptonctype = {'S1' : NC_CHAR,
* 'i1' : NC_BYTE,
* 'u1' : NC_UBYTE, # <<<<<<<<<<<<<<
* 'i2' : NC_SHORT,
* 'u2' : NC_USHORT,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_UBYTE); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 986; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u1, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_UBYTE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 999, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u1, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":987
+ /* "netCDF4/_netCDF4.pyx":1000
* 'i1' : NC_BYTE,
* 'u1' : NC_UBYTE,
* 'i2' : NC_SHORT, # <<<<<<<<<<<<<<
* 'u2' : NC_USHORT,
* 'i4' : NC_INT,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_SHORT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 987; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i2, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_SHORT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1000, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i2, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":988
+ /* "netCDF4/_netCDF4.pyx":1001
* 'u1' : NC_UBYTE,
* 'i2' : NC_SHORT,
* 'u2' : NC_USHORT, # <<<<<<<<<<<<<<
* 'i4' : NC_INT,
* 'u4' : NC_UINT,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_USHORT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 988; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u2, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_USHORT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1001, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u2, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":989
+ /* "netCDF4/_netCDF4.pyx":1002
* 'i2' : NC_SHORT,
* 'u2' : NC_USHORT,
* 'i4' : NC_INT, # <<<<<<<<<<<<<<
* 'u4' : NC_UINT,
* 'i8' : NC_INT64,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_INT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 989; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i4, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_INT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1002, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i4, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":990
+ /* "netCDF4/_netCDF4.pyx":1003
* 'u2' : NC_USHORT,
* 'i4' : NC_INT,
* 'u4' : NC_UINT, # <<<<<<<<<<<<<<
* 'i8' : NC_INT64,
* 'u8' : NC_UINT64,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_UINT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 990; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u4, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_UINT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1003, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u4, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":991
+ /* "netCDF4/_netCDF4.pyx":1004
* 'i4' : NC_INT,
* 'u4' : NC_UINT,
* 'i8' : NC_INT64, # <<<<<<<<<<<<<<
* 'u8' : NC_UINT64,
* 'f4' : NC_FLOAT,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_INT64); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 991; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i8, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_INT64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1004, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i8, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":992
+ /* "netCDF4/_netCDF4.pyx":1005
* 'u4' : NC_UINT,
* 'i8' : NC_INT64,
* 'u8' : NC_UINT64, # <<<<<<<<<<<<<<
* 'f4' : NC_FLOAT,
* 'f8' : NC_DOUBLE}
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_UINT64); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 992; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u8, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_UINT64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1005, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u8, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":993
+ /* "netCDF4/_netCDF4.pyx":1006
* 'i8' : NC_INT64,
* 'u8' : NC_UINT64,
* 'f4' : NC_FLOAT, # <<<<<<<<<<<<<<
* 'f8' : NC_DOUBLE}
*
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_FLOAT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 993; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_f4, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_FLOAT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1006, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_f4, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":994
+ /* "netCDF4/_netCDF4.pyx":1007
* 'u8' : NC_UINT64,
* 'f4' : NC_FLOAT,
* 'f8' : NC_DOUBLE} # <<<<<<<<<<<<<<
*
* # just integer types.
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_DOUBLE); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 994; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_f8, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_nptonctype, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 984; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_DOUBLE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1007, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_f8, __pyx_t_2) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_nptonctype, __pyx_t_1) < 0) __PYX_ERR(0, 997, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":997
+ /* "netCDF4/_netCDF4.pyx":1010
*
* # just integer types.
* _intnptonctype = {'i1' : NC_BYTE, # <<<<<<<<<<<<<<
* 'u1' : NC_UBYTE,
* 'i2' : NC_SHORT,
*/
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1010, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_BYTE); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i1, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_BYTE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i1, __pyx_t_2) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":998
+ /* "netCDF4/_netCDF4.pyx":1011
* # just integer types.
* _intnptonctype = {'i1' : NC_BYTE,
* 'u1' : NC_UBYTE, # <<<<<<<<<<<<<<
* 'i2' : NC_SHORT,
* 'u2' : NC_USHORT,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_UBYTE); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 998; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u1, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_UBYTE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1011, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u1, __pyx_t_2) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":999
+ /* "netCDF4/_netCDF4.pyx":1012
* _intnptonctype = {'i1' : NC_BYTE,
* 'u1' : NC_UBYTE,
* 'i2' : NC_SHORT, # <<<<<<<<<<<<<<
* 'u2' : NC_USHORT,
* 'i4' : NC_INT,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_SHORT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 999; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i2, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_SHORT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1012, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i2, __pyx_t_2) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1000
+ /* "netCDF4/_netCDF4.pyx":1013
* 'u1' : NC_UBYTE,
* 'i2' : NC_SHORT,
* 'u2' : NC_USHORT, # <<<<<<<<<<<<<<
* 'i4' : NC_INT,
* 'u4' : NC_UINT,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_USHORT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1000; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u2, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_USHORT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1013, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u2, __pyx_t_2) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1001
+ /* "netCDF4/_netCDF4.pyx":1014
* 'i2' : NC_SHORT,
* 'u2' : NC_USHORT,
* 'i4' : NC_INT, # <<<<<<<<<<<<<<
* 'u4' : NC_UINT,
* 'i8' : NC_INT64,
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_INT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1001; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i4, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_INT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1014, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i4, __pyx_t_2) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1002
+ /* "netCDF4/_netCDF4.pyx":1015
* 'u2' : NC_USHORT,
* 'i4' : NC_INT,
* 'u4' : NC_UINT, # <<<<<<<<<<<<<<
* 'i8' : NC_INT64,
* 'u8' : NC_UINT64}
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_UINT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u4, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_UINT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1015, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u4, __pyx_t_2) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1003
+ /* "netCDF4/_netCDF4.pyx":1016
* 'i4' : NC_INT,
* 'u4' : NC_UINT,
* 'i8' : NC_INT64, # <<<<<<<<<<<<<<
* 'u8' : NC_UINT64}
*
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_INT64); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1003; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i8, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_INT64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1016, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_i8, __pyx_t_2) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1004
+ /* "netCDF4/_netCDF4.pyx":1017
* 'u4' : NC_UINT,
* 'i8' : NC_INT64,
* 'u8' : NC_UINT64} # <<<<<<<<<<<<<<
*
* # create dictionary mapping string identifiers to netcdf format codes
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_UINT64); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1004; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u8, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_intnptonctype, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 997; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_UINT64); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1017, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_u8, __pyx_t_2) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_intnptonctype, __pyx_t_1) < 0) __PYX_ERR(0, 1010, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1007
+ /* "netCDF4/_netCDF4.pyx":1020
*
* # create dictionary mapping string identifiers to netcdf format codes
* _format_dict = {'NETCDF3_CLASSIC' : NC_FORMAT_CLASSIC, # <<<<<<<<<<<<<<
* 'NETCDF4_CLASSIC' : NC_FORMAT_NETCDF4_CLASSIC,
* 'NETCDF4' : NC_FORMAT_NETCDF4}
*/
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1020, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_FORMAT_CLASSIC); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_NETCDF3_CLASSIC, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_FORMAT_CLASSIC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1020, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_NETCDF3_CLASSIC, __pyx_t_2) < 0) __PYX_ERR(0, 1020, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1008
+ /* "netCDF4/_netCDF4.pyx":1021
* # create dictionary mapping string identifiers to netcdf format codes
* _format_dict = {'NETCDF3_CLASSIC' : NC_FORMAT_CLASSIC,
* 'NETCDF4_CLASSIC' : NC_FORMAT_NETCDF4_CLASSIC, # <<<<<<<<<<<<<<
* 'NETCDF4' : NC_FORMAT_NETCDF4}
* IF HAS_CDF5_FORMAT:
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_FORMAT_NETCDF4_CLASSIC); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1008; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_NETCDF4_CLASSIC, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_FORMAT_NETCDF4_CLASSIC); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1021, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_NETCDF4_CLASSIC, __pyx_t_2) < 0) __PYX_ERR(0, 1020, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1009
+ /* "netCDF4/_netCDF4.pyx":1022
* _format_dict = {'NETCDF3_CLASSIC' : NC_FORMAT_CLASSIC,
* 'NETCDF4_CLASSIC' : NC_FORMAT_NETCDF4_CLASSIC,
* 'NETCDF4' : NC_FORMAT_NETCDF4} # <<<<<<<<<<<<<<
* IF HAS_CDF5_FORMAT:
* # NETCDF3_64BIT deprecated, saved for compatibility.
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_FORMAT_NETCDF4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1009; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_NETCDF4, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_format_dict, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1007; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_FORMAT_NETCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1022, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_NETCDF4, __pyx_t_2) < 0) __PYX_ERR(0, 1020, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_format_dict, __pyx_t_1) < 0) __PYX_ERR(0, 1020, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1016
+ /* "netCDF4/_netCDF4.pyx":1029
* _format_dict['NETCDF3_64BIT_DATA'] = NC_FORMAT_64BIT_DATA
* ELSE:
* _format_dict['NETCDF3_64BIT'] = NC_FORMAT_64BIT # <<<<<<<<<<<<<<
* # invert dictionary mapping
* _reverse_format_dict = dict((v, k) for k, v in _format_dict.iteritems())
*/
- __pyx_t_1 = __Pyx_PyInt_From_int(NC_FORMAT_64BIT); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1016; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(NC_FORMAT_64BIT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1029, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1016; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (unlikely(PyObject_SetItem(__pyx_t_7, __pyx_n_s_NETCDF3_64BIT, __pyx_t_1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1016; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1029, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_n_s_NETCDF3_64BIT, __pyx_t_1) < 0)) __PYX_ERR(0, 1029, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1018
+ /* "netCDF4/_netCDF4.pyx":1031
* _format_dict['NETCDF3_64BIT'] = NC_FORMAT_64BIT
* # invert dictionary mapping
* _reverse_format_dict = dict((v, k) for k, v in _format_dict.iteritems()) # <<<<<<<<<<<<<<
* # add duplicate entry (NETCDF3_64BIT == NETCDF3_64BIT_OFFSET)
* IF HAS_CDF5_FORMAT:
*/
- __pyx_t_1 = __pyx_pf_7netCDF4_8_netCDF4_22genexpr(NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __pyx_pf_7netCDF4_8_netCDF4_22genexpr(NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1031, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_Generator_Next(__pyx_t_1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = __Pyx_Generator_Next(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1031, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_reverse_format_dict, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1018; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_reverse_format_dict, __pyx_t_2) < 0) __PYX_ERR(0, 1031, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1023
+ /* "netCDF4/_netCDF4.pyx":1036
* _format_dict['NETCDF3_64BIT'] = NC_FORMAT_64BIT_OFFSET
* ELSE:
* _format_dict['NETCDF3_64BIT_OFFSET'] = NC_FORMAT_64BIT # <<<<<<<<<<<<<<
*
* # default fill_value to numpy datatype mapping.
*/
- __pyx_t_7 = __Pyx_PyInt_From_int(NC_FORMAT_64BIT); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_PyInt_From_int(NC_FORMAT_64BIT); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1036, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_format_dict); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1036, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_n_s_NETCDF3_64BIT_OFFSET, __pyx_t_7) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1023; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_n_s_NETCDF3_64BIT_OFFSET, __pyx_t_2) < 0)) __PYX_ERR(0, 1036, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1027
+ /* "netCDF4/_netCDF4.pyx":1040
* # default fill_value to numpy datatype mapping.
* default_fillvals = {#'S1':NC_FILL_CHAR,
* 'S1':'\0', # <<<<<<<<<<<<<<
* 'i1':NC_FILL_BYTE,
* 'u1':NC_FILL_UBYTE,
*/
- __pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_S1, __pyx_kp_s_) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1040, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_S1, __pyx_kp_s_) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1028
+ /* "netCDF4/_netCDF4.pyx":1041
* default_fillvals = {#'S1':NC_FILL_CHAR,
* 'S1':'\0',
* 'i1':NC_FILL_BYTE, # <<<<<<<<<<<<<<
* 'u1':NC_FILL_UBYTE,
* 'i2':NC_FILL_SHORT,
*/
- __pyx_t_1 = __Pyx_PyInt_From_int(NC_FILL_BYTE); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1028; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(NC_FILL_BYTE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1041, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_i1, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_i1, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1029
+ /* "netCDF4/_netCDF4.pyx":1042
* 'S1':'\0',
* 'i1':NC_FILL_BYTE,
* 'u1':NC_FILL_UBYTE, # <<<<<<<<<<<<<<
* 'i2':NC_FILL_SHORT,
* 'u2':NC_FILL_USHORT,
*/
- __pyx_t_1 = __Pyx_PyInt_From_int(NC_FILL_UBYTE); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1029; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(NC_FILL_UBYTE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1042, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_u1, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_u1, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1030
+ /* "netCDF4/_netCDF4.pyx":1043
* 'i1':NC_FILL_BYTE,
* 'u1':NC_FILL_UBYTE,
* 'i2':NC_FILL_SHORT, # <<<<<<<<<<<<<<
* 'u2':NC_FILL_USHORT,
* 'i4':NC_FILL_INT,
*/
- __pyx_t_1 = __Pyx_PyInt_From_int(NC_FILL_SHORT); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1030; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(NC_FILL_SHORT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1043, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_i2, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_i2, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1031
+ /* "netCDF4/_netCDF4.pyx":1044
* 'u1':NC_FILL_UBYTE,
* 'i2':NC_FILL_SHORT,
* 'u2':NC_FILL_USHORT, # <<<<<<<<<<<<<<
* 'i4':NC_FILL_INT,
* 'u4':NC_FILL_UINT,
*/
- __pyx_t_1 = __Pyx_PyInt_From_int(NC_FILL_USHORT); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1031; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_int(NC_FILL_USHORT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1044, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_u2, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_u2, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1032
+ /* "netCDF4/_netCDF4.pyx":1045
* 'i2':NC_FILL_SHORT,
* 'u2':NC_FILL_USHORT,
* 'i4':NC_FILL_INT, # <<<<<<<<<<<<<<
* 'u4':NC_FILL_UINT,
* 'i8':NC_FILL_INT64,
*/
- __pyx_t_1 = __Pyx_PyInt_From_long(NC_FILL_INT); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1032; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_long(NC_FILL_INT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_i4, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_i4, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1033
+ /* "netCDF4/_netCDF4.pyx":1046
* 'u2':NC_FILL_USHORT,
* 'i4':NC_FILL_INT,
* 'u4':NC_FILL_UINT, # <<<<<<<<<<<<<<
* 'i8':NC_FILL_INT64,
* 'u8':NC_FILL_UINT64,
*/
- __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(NC_FILL_UINT); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1033; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(NC_FILL_UINT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1046, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_u4, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_u4, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1034
+ /* "netCDF4/_netCDF4.pyx":1047
* 'i4':NC_FILL_INT,
* 'u4':NC_FILL_UINT,
* 'i8':NC_FILL_INT64, # <<<<<<<<<<<<<<
* 'u8':NC_FILL_UINT64,
* 'f4':NC_FILL_FLOAT,
*/
- __pyx_t_1 = __Pyx_PyInt_From_PY_LONG_LONG(NC_FILL_INT64); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1034; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_PY_LONG_LONG(NC_FILL_INT64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1047, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_i8, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_i8, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1035
+ /* "netCDF4/_netCDF4.pyx":1048
* 'u4':NC_FILL_UINT,
* 'i8':NC_FILL_INT64,
* 'u8':NC_FILL_UINT64, # <<<<<<<<<<<<<<
* 'f4':NC_FILL_FLOAT,
* 'f8':NC_FILL_DOUBLE}
*/
- __pyx_t_1 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(NC_FILL_UINT64); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1035; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyInt_From_unsigned_PY_LONG_LONG(NC_FILL_UINT64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1048, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_u8, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_u8, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1036
+ /* "netCDF4/_netCDF4.pyx":1049
* 'i8':NC_FILL_INT64,
* 'u8':NC_FILL_UINT64,
* 'f4':NC_FILL_FLOAT, # <<<<<<<<<<<<<<
* 'f8':NC_FILL_DOUBLE}
*
*/
- __pyx_t_1 = PyFloat_FromDouble(NC_FILL_FLOAT); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1036; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyFloat_FromDouble(NC_FILL_FLOAT); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1049, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_f4, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_f4, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1037
+ /* "netCDF4/_netCDF4.pyx":1050
* 'u8':NC_FILL_UINT64,
* 'f4':NC_FILL_FLOAT,
* 'f8':NC_FILL_DOUBLE} # <<<<<<<<<<<<<<
*
* # logical for native endian type.
*/
- __pyx_t_1 = PyFloat_FromDouble(NC_FILL_DOUBLE); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1037; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyFloat_FromDouble(NC_FILL_DOUBLE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1050, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_f8, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1027; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_f8, __pyx_t_1) < 0) __PYX_ERR(0, 1040, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_default_fillvals, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1026; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_default_fillvals, __pyx_t_2) < 0) __PYX_ERR(0, 1039, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1040
+ /* "netCDF4/_netCDF4.pyx":1053
*
* # logical for native endian type.
* is_native_little = numpy.dtype('<f4').byteorder == '=' # <<<<<<<<<<<<<<
* is_native_big = numpy.dtype('>f4').byteorder == '='
*
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1053, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1053, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__133, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__128, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1053, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1053, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = PyObject_RichCompare(__pyx_t_1, __pyx_kp_s__36, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_kp_s__36, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1053, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_native_little, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1040; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_native_little, __pyx_t_2) < 0) __PYX_ERR(0, 1053, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1041
+ /* "netCDF4/_netCDF4.pyx":1054
* # logical for native endian type.
* is_native_little = numpy.dtype('<f4').byteorder == '='
* is_native_big = numpy.dtype('>f4').byteorder == '=' # <<<<<<<<<<<<<<
*
* # hard code this here, instead of importing from netcdf.h
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_numpy); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1054, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_dtype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1054, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__134, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__129, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1054, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_byteorder); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1054, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = PyObject_RichCompare(__pyx_t_1, __pyx_kp_s__36, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyObject_RichCompare(__pyx_t_1, __pyx_kp_s__36, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1054, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_native_big, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1041; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_is_native_big, __pyx_t_2) < 0) __PYX_ERR(0, 1054, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- /* "netCDF4/_netCDF4.pyx":1045
+ /* "netCDF4/_netCDF4.pyx":1058
* # hard code this here, instead of importing from netcdf.h
* # so it will compile with versions <= 4.2.
* NC_DISKLESS = 0x0008 # <<<<<<<<<<<<<<
* # encoding used to convert strings to bytes when writing text data
* # to the netcdf file, and for converting bytes to strings when reading
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_NC_DISKLESS, __pyx_int_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1045; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NC_DISKLESS, __pyx_int_8) < 0) __PYX_ERR(0, 1058, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1049
+ /* "netCDF4/_netCDF4.pyx":1062
* # to the netcdf file, and for converting bytes to strings when reading
* # from the netcdf file.
* default_encoding = 'utf-8' # <<<<<<<<<<<<<<
* # unicode decode/encode error handling. Replace bad chars with "?"
* # can be set to 'strict' or 'ignore'.
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_default_encoding, __pyx_kp_s_utf_8) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1049; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_default_encoding, __pyx_kp_s_utf_8) < 0) __PYX_ERR(0, 1062, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1052
+ /* "netCDF4/_netCDF4.pyx":1065
* # unicode decode/encode error handling. Replace bad chars with "?"
* # can be set to 'strict' or 'ignore'.
* unicode_error = 'replace' # <<<<<<<<<<<<<<
* python3 = sys.version_info[0] > 2
*
*/
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_unicode_error, __pyx_n_s_replace) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1052; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_unicode_error, __pyx_n_s_replace) < 0) __PYX_ERR(0, 1065, __pyx_L1_error)
- /* "netCDF4/_netCDF4.pyx":1053
+ /* "netCDF4/_netCDF4.pyx":1066
* # can be set to 'strict' or 'ignore'.
* unicode_error = 'replace'
* python3 = sys.version_info[0] > 2 # <<<<<<<<<<<<<<
*
* _nctonptype = {}
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_version_info); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1066, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_version_info); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1066, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;};
- __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1066, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_python3, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1053; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_int_2, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1066, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_python3, __pyx_t_1) < 0) __PYX_ERR(0, 1066, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1055
+ /* "netCDF4/_netCDF4.pyx":1068
* python3 = sys.version_info[0] > 2
*
* _nctonptype = {} # <<<<<<<<<<<<<<
* for _key,_value in _nptonctype.items():
* _nctonptype[_value] = _key
*/
- __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1068, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_nctonptype, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1055; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_nctonptype, __pyx_t_1) < 0) __PYX_ERR(0, 1068, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1056
+ /* "netCDF4/_netCDF4.pyx":1069
*
* _nctonptype = {}
* for _key,_value in _nptonctype.items(): # <<<<<<<<<<<<<<
* _nctonptype[_value] = _key
* _supportedtypes = _nptonctype.keys()
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_items); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1069, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
- __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
- if (likely(__pyx_t_7)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
- __Pyx_INCREF(__pyx_t_7);
+ __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_items); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1069, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = NULL;
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_11))) {
+ __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_11);
+ if (likely(__pyx_t_2)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
+ __Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_2, function);
+ __Pyx_DECREF_SET(__pyx_t_11, function);
}
}
- if (__pyx_t_7) {
- __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_7); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ if (__pyx_t_2) {
+ __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1069, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
- __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1069, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) {
- __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_16 = 0;
- __pyx_t_17 = NULL;
+ __pyx_t_11 = __pyx_t_1; __Pyx_INCREF(__pyx_t_11); __pyx_t_17 = 0;
+ __pyx_t_18 = NULL;
} else {
- __pyx_t_16 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_17 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_17)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_17 = -1; __pyx_t_11 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1069, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_18 = Py_TYPE(__pyx_t_11)->tp_iternext; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 1069, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
for (;;) {
- if (likely(!__pyx_t_17)) {
- if (likely(PyList_CheckExact(__pyx_t_2))) {
- if (__pyx_t_16 >= PyList_GET_SIZE(__pyx_t_2)) break;
+ if (likely(!__pyx_t_18)) {
+ if (likely(PyList_CheckExact(__pyx_t_11))) {
+ if (__pyx_t_17 >= PyList_GET_SIZE(__pyx_t_11)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_16); __Pyx_INCREF(__pyx_t_1); __pyx_t_16++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyList_GET_ITEM(__pyx_t_11, __pyx_t_17); __Pyx_INCREF(__pyx_t_1); __pyx_t_17++; if (unlikely(0 < 0)) __PYX_ERR(0, 1069, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_16); __pyx_t_16++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_11, __pyx_t_17); __pyx_t_17++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1069, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
} else {
- if (__pyx_t_16 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
+ if (__pyx_t_17 >= PyTuple_GET_SIZE(__pyx_t_11)) break;
#if CYTHON_COMPILING_IN_CPYTHON
- __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_16); __Pyx_INCREF(__pyx_t_1); __pyx_t_16++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_11, __pyx_t_17); __Pyx_INCREF(__pyx_t_1); __pyx_t_17++; if (unlikely(0 < 0)) __PYX_ERR(0, 1069, __pyx_L1_error)
#else
- __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_16); __pyx_t_16++; if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = PySequence_ITEM(__pyx_t_11, __pyx_t_17); __pyx_t_17++; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1069, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
#endif
}
} else {
- __pyx_t_1 = __pyx_t_17(__pyx_t_2);
+ __pyx_t_1 = __pyx_t_18(__pyx_t_11);
if (unlikely(!__pyx_t_1)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
- else {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ else __PYX_ERR(0, 1069, __pyx_L1_error)
}
break;
}
@@ -77762,70 +77066,70 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __PYX_ERR(0, 1069, __pyx_L1_error)
}
#if CYTHON_COMPILING_IN_CPYTHON
if (likely(PyTuple_CheckExact(sequence))) {
- __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0);
- __pyx_t_13 = PyTuple_GET_ITEM(sequence, 1);
+ __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1);
} else {
- __pyx_t_7 = PyList_GET_ITEM(sequence, 0);
- __pyx_t_13 = PyList_GET_ITEM(sequence, 1);
+ __pyx_t_2 = PyList_GET_ITEM(sequence, 0);
+ __pyx_t_7 = PyList_GET_ITEM(sequence, 1);
}
+ __Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_7);
- __Pyx_INCREF(__pyx_t_13);
#else
- __pyx_t_7 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1069, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_7 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1069, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- __pyx_t_13 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
- __pyx_t_11 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_13 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1069, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_13);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- __pyx_t_18 = Py_TYPE(__pyx_t_11)->tp_iternext;
- index = 0; __pyx_t_7 = __pyx_t_18(__pyx_t_11); if (unlikely(!__pyx_t_7)) goto __pyx_L35_unpacking_failed;
+ __pyx_t_19 = Py_TYPE(__pyx_t_13)->tp_iternext;
+ index = 0; __pyx_t_2 = __pyx_t_19(__pyx_t_13); if (unlikely(!__pyx_t_2)) goto __pyx_L38_unpacking_failed;
+ __Pyx_GOTREF(__pyx_t_2);
+ index = 1; __pyx_t_7 = __pyx_t_19(__pyx_t_13); if (unlikely(!__pyx_t_7)) goto __pyx_L38_unpacking_failed;
__Pyx_GOTREF(__pyx_t_7);
- index = 1; __pyx_t_13 = __pyx_t_18(__pyx_t_11); if (unlikely(!__pyx_t_13)) goto __pyx_L35_unpacking_failed;
- __Pyx_GOTREF(__pyx_t_13);
- if (__Pyx_IternextUnpackEndCheck(__pyx_t_18(__pyx_t_11), 2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_18 = NULL;
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- goto __pyx_L36_unpacking_done;
- __pyx_L35_unpacking_failed:;
- __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- __pyx_t_18 = NULL;
+ if (__Pyx_IternextUnpackEndCheck(__pyx_t_19(__pyx_t_13), 2) < 0) __PYX_ERR(0, 1069, __pyx_L1_error)
+ __pyx_t_19 = NULL;
+ __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ goto __pyx_L39_unpacking_done;
+ __pyx_L38_unpacking_failed:;
+ __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_19 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
- {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_L36_unpacking_done:;
+ __PYX_ERR(0, 1069, __pyx_L1_error)
+ __pyx_L39_unpacking_done:;
}
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_key, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_key, __pyx_t_2) < 0) __PYX_ERR(0, 1069, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_value_2, __pyx_t_7) < 0) __PYX_ERR(0, 1069, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_value_2, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1056; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
- /* "netCDF4/_netCDF4.pyx":1057
+ /* "netCDF4/_netCDF4.pyx":1070
* _nctonptype = {}
* for _key,_value in _nptonctype.items():
* _nctonptype[_value] = _key # <<<<<<<<<<<<<<
* _supportedtypes = _nptonctype.keys()
* # make sure NC_CHAR points to S1
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_key); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1070, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_13 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_value_2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1070, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
- if (unlikely(PyObject_SetItem(__pyx_t_13, __pyx_t_7, __pyx_t_1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1057; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_value_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1070, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (unlikely(PyObject_SetItem(__pyx_t_7, __pyx_t_2, __pyx_t_1) < 0)) __PYX_ERR(0, 1070, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
- /* "netCDF4/_netCDF4.pyx":1056
+ /* "netCDF4/_netCDF4.pyx":1069
*
* _nctonptype = {}
* for _key,_value in _nptonctype.items(): # <<<<<<<<<<<<<<
@@ -77833,478 +77137,478 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* _supportedtypes = _nptonctype.keys()
*/
}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1058
+ /* "netCDF4/_netCDF4.pyx":1071
* for _key,_value in _nptonctype.items():
* _nctonptype[_value] = _key
* _supportedtypes = _nptonctype.keys() # <<<<<<<<<<<<<<
* # make sure NC_CHAR points to S1
* _nctonptype[NC_CHAR]='S1'
*/
- __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_nptonctype); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1071, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
- __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_keys); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_keys); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1071, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = NULL;
- if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_7))) {
- __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_7);
+ if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) {
+ __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_1)) {
- PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
- __Pyx_DECREF_SET(__pyx_t_7, function);
+ __Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_1) {
- __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1071, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
- __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1071, __pyx_L1_error)
}
- __Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_supportedtypes, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1058; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_supportedtypes, __pyx_t_11) < 0) __PYX_ERR(0, 1071, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1060
+ /* "netCDF4/_netCDF4.pyx":1073
* _supportedtypes = _nptonctype.keys()
* # make sure NC_CHAR points to S1
* _nctonptype[NC_CHAR]='S1' # <<<<<<<<<<<<<<
*
* # internal C functions.
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(__Pyx_SetItemInt(__pyx_t_2, NC_CHAR, __pyx_n_s_S1, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1060; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_nctonptype); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1073, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(__Pyx_SetItemInt(__pyx_t_11, NC_CHAR, __pyx_n_s_S1, int, 1, __Pyx_PyInt_From_int, 0, 1, 1) < 0)) __PYX_ERR(0, 1073, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1156
+ /* "netCDF4/_netCDF4.pyx":1169
* return value_arr
*
* def _set_default_format(object format='NETCDF4'): # <<<<<<<<<<<<<<
* # Private function to set the netCDF file format
* if format not in _format_dict:
*/
- __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_5_set_default_format, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1156; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_set_default_format, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1156; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_5_set_default_format, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1169, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_set_default_format, __pyx_t_11) < 0) __PYX_ERR(0, 1169, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1539
+ /* "netCDF4/_netCDF4.pyx":1549
*
* _private_atts =\
* ['_grpid','_grp','_varid','groups','dimensions','variables','dtype','data_model','disk_format', # <<<<<<<<<<<<<<
* '_nunlimdim','path','parent','ndim','mask','scale','cmptypes','vltypes','enumtypes','_isprimitive',
* 'file_format','_isvlen','_isenum','_iscompound','_cmptype','_vltype','_enumtype','name',
*/
- __pyx_t_2 = PyList_New(30); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1539; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_11 = PyList_New(30); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1549, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
__Pyx_INCREF(__pyx_n_s_grpid);
__Pyx_GIVEREF(__pyx_n_s_grpid);
- PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_grpid);
+ PyList_SET_ITEM(__pyx_t_11, 0, __pyx_n_s_grpid);
__Pyx_INCREF(__pyx_n_s_grp_2);
__Pyx_GIVEREF(__pyx_n_s_grp_2);
- PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_grp_2);
+ PyList_SET_ITEM(__pyx_t_11, 1, __pyx_n_s_grp_2);
__Pyx_INCREF(__pyx_n_s_varid);
__Pyx_GIVEREF(__pyx_n_s_varid);
- PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_varid);
+ PyList_SET_ITEM(__pyx_t_11, 2, __pyx_n_s_varid);
__Pyx_INCREF(__pyx_n_s_groups);
__Pyx_GIVEREF(__pyx_n_s_groups);
- PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_groups);
+ PyList_SET_ITEM(__pyx_t_11, 3, __pyx_n_s_groups);
__Pyx_INCREF(__pyx_n_s_dimensions);
__Pyx_GIVEREF(__pyx_n_s_dimensions);
- PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_dimensions);
+ PyList_SET_ITEM(__pyx_t_11, 4, __pyx_n_s_dimensions);
__Pyx_INCREF(__pyx_n_s_variables);
__Pyx_GIVEREF(__pyx_n_s_variables);
- PyList_SET_ITEM(__pyx_t_2, 5, __pyx_n_s_variables);
+ PyList_SET_ITEM(__pyx_t_11, 5, __pyx_n_s_variables);
__Pyx_INCREF(__pyx_n_s_dtype);
__Pyx_GIVEREF(__pyx_n_s_dtype);
- PyList_SET_ITEM(__pyx_t_2, 6, __pyx_n_s_dtype);
+ PyList_SET_ITEM(__pyx_t_11, 6, __pyx_n_s_dtype);
__Pyx_INCREF(__pyx_n_s_data_model);
__Pyx_GIVEREF(__pyx_n_s_data_model);
- PyList_SET_ITEM(__pyx_t_2, 7, __pyx_n_s_data_model);
- __Pyx_INCREF(__pyx_n_s_disk_format);
- __Pyx_GIVEREF(__pyx_n_s_disk_format);
- PyList_SET_ITEM(__pyx_t_2, 8, __pyx_n_s_disk_format);
+ PyList_SET_ITEM(__pyx_t_11, 7, __pyx_n_s_data_model);
+ __Pyx_INCREF(__pyx_n_s_disk_format_2);
+ __Pyx_GIVEREF(__pyx_n_s_disk_format_2);
+ PyList_SET_ITEM(__pyx_t_11, 8, __pyx_n_s_disk_format_2);
__Pyx_INCREF(__pyx_n_s_nunlimdim);
__Pyx_GIVEREF(__pyx_n_s_nunlimdim);
- PyList_SET_ITEM(__pyx_t_2, 9, __pyx_n_s_nunlimdim);
+ PyList_SET_ITEM(__pyx_t_11, 9, __pyx_n_s_nunlimdim);
__Pyx_INCREF(__pyx_n_s_path);
__Pyx_GIVEREF(__pyx_n_s_path);
- PyList_SET_ITEM(__pyx_t_2, 10, __pyx_n_s_path);
+ PyList_SET_ITEM(__pyx_t_11, 10, __pyx_n_s_path);
__Pyx_INCREF(__pyx_n_s_parent);
__Pyx_GIVEREF(__pyx_n_s_parent);
- PyList_SET_ITEM(__pyx_t_2, 11, __pyx_n_s_parent);
+ PyList_SET_ITEM(__pyx_t_11, 11, __pyx_n_s_parent);
__Pyx_INCREF(__pyx_n_s_ndim);
__Pyx_GIVEREF(__pyx_n_s_ndim);
- PyList_SET_ITEM(__pyx_t_2, 12, __pyx_n_s_ndim);
+ PyList_SET_ITEM(__pyx_t_11, 12, __pyx_n_s_ndim);
__Pyx_INCREF(__pyx_n_s_mask);
__Pyx_GIVEREF(__pyx_n_s_mask);
- PyList_SET_ITEM(__pyx_t_2, 13, __pyx_n_s_mask);
+ PyList_SET_ITEM(__pyx_t_11, 13, __pyx_n_s_mask);
__Pyx_INCREF(__pyx_n_s_scale);
__Pyx_GIVEREF(__pyx_n_s_scale);
- PyList_SET_ITEM(__pyx_t_2, 14, __pyx_n_s_scale);
+ PyList_SET_ITEM(__pyx_t_11, 14, __pyx_n_s_scale);
__Pyx_INCREF(__pyx_n_s_cmptypes);
__Pyx_GIVEREF(__pyx_n_s_cmptypes);
- PyList_SET_ITEM(__pyx_t_2, 15, __pyx_n_s_cmptypes);
+ PyList_SET_ITEM(__pyx_t_11, 15, __pyx_n_s_cmptypes);
__Pyx_INCREF(__pyx_n_s_vltypes);
__Pyx_GIVEREF(__pyx_n_s_vltypes);
- PyList_SET_ITEM(__pyx_t_2, 16, __pyx_n_s_vltypes);
+ PyList_SET_ITEM(__pyx_t_11, 16, __pyx_n_s_vltypes);
__Pyx_INCREF(__pyx_n_s_enumtypes);
__Pyx_GIVEREF(__pyx_n_s_enumtypes);
- PyList_SET_ITEM(__pyx_t_2, 17, __pyx_n_s_enumtypes);
+ PyList_SET_ITEM(__pyx_t_11, 17, __pyx_n_s_enumtypes);
__Pyx_INCREF(__pyx_n_s_isprimitive);
__Pyx_GIVEREF(__pyx_n_s_isprimitive);
- PyList_SET_ITEM(__pyx_t_2, 18, __pyx_n_s_isprimitive);
+ PyList_SET_ITEM(__pyx_t_11, 18, __pyx_n_s_isprimitive);
__Pyx_INCREF(__pyx_n_s_file_format);
__Pyx_GIVEREF(__pyx_n_s_file_format);
- PyList_SET_ITEM(__pyx_t_2, 19, __pyx_n_s_file_format);
+ PyList_SET_ITEM(__pyx_t_11, 19, __pyx_n_s_file_format);
__Pyx_INCREF(__pyx_n_s_isvlen);
__Pyx_GIVEREF(__pyx_n_s_isvlen);
- PyList_SET_ITEM(__pyx_t_2, 20, __pyx_n_s_isvlen);
+ PyList_SET_ITEM(__pyx_t_11, 20, __pyx_n_s_isvlen);
__Pyx_INCREF(__pyx_n_s_isenum);
__Pyx_GIVEREF(__pyx_n_s_isenum);
- PyList_SET_ITEM(__pyx_t_2, 21, __pyx_n_s_isenum);
+ PyList_SET_ITEM(__pyx_t_11, 21, __pyx_n_s_isenum);
__Pyx_INCREF(__pyx_n_s_iscompound);
__Pyx_GIVEREF(__pyx_n_s_iscompound);
- PyList_SET_ITEM(__pyx_t_2, 22, __pyx_n_s_iscompound);
+ PyList_SET_ITEM(__pyx_t_11, 22, __pyx_n_s_iscompound);
__Pyx_INCREF(__pyx_n_s_cmptype);
__Pyx_GIVEREF(__pyx_n_s_cmptype);
- PyList_SET_ITEM(__pyx_t_2, 23, __pyx_n_s_cmptype);
+ PyList_SET_ITEM(__pyx_t_11, 23, __pyx_n_s_cmptype);
__Pyx_INCREF(__pyx_n_s_vltype);
__Pyx_GIVEREF(__pyx_n_s_vltype);
- PyList_SET_ITEM(__pyx_t_2, 24, __pyx_n_s_vltype);
+ PyList_SET_ITEM(__pyx_t_11, 24, __pyx_n_s_vltype);
__Pyx_INCREF(__pyx_n_s_enumtype);
__Pyx_GIVEREF(__pyx_n_s_enumtype);
- PyList_SET_ITEM(__pyx_t_2, 25, __pyx_n_s_enumtype);
+ PyList_SET_ITEM(__pyx_t_11, 25, __pyx_n_s_enumtype);
__Pyx_INCREF(__pyx_n_s_name);
__Pyx_GIVEREF(__pyx_n_s_name);
- PyList_SET_ITEM(__pyx_t_2, 26, __pyx_n_s_name);
+ PyList_SET_ITEM(__pyx_t_11, 26, __pyx_n_s_name);
__Pyx_INCREF(__pyx_n_s_orthogoral_indexing);
__Pyx_GIVEREF(__pyx_n_s_orthogoral_indexing);
- PyList_SET_ITEM(__pyx_t_2, 27, __pyx_n_s_orthogoral_indexing);
+ PyList_SET_ITEM(__pyx_t_11, 27, __pyx_n_s_orthogoral_indexing);
__Pyx_INCREF(__pyx_n_s_keepweakref);
__Pyx_GIVEREF(__pyx_n_s_keepweakref);
- PyList_SET_ITEM(__pyx_t_2, 28, __pyx_n_s_keepweakref);
+ PyList_SET_ITEM(__pyx_t_11, 28, __pyx_n_s_keepweakref);
__Pyx_INCREF(__pyx_n_s_has_lsd);
__Pyx_GIVEREF(__pyx_n_s_has_lsd);
- PyList_SET_ITEM(__pyx_t_2, 29, __pyx_n_s_has_lsd);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_private_atts, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1538; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ PyList_SET_ITEM(__pyx_t_11, 29, __pyx_n_s_has_lsd);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_private_atts, __pyx_t_11) < 0) __PYX_ERR(0, 1548, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1543
+ /* "netCDF4/_netCDF4.pyx":1553
* 'file_format','_isvlen','_isenum','_iscompound','_cmptype','_vltype','_enumtype','name',
* '__orthogoral_indexing__','keepweakref','_has_lsd']
* __pdoc__ = {} # <<<<<<<<<<<<<<
*
* cdef class Dataset:
*/
- __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_pdoc, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1543; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = PyDict_New(); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1553, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_pdoc, __pyx_t_11) < 0) __PYX_ERR(0, 1553, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1619
+ /* "netCDF4/_netCDF4.pyx":1629
* keepweakref
* # Docstrings for class variables (used by pdoc).
* __pdoc__['Dataset.dimensions']=\ # <<<<<<<<<<<<<<
* """The `dimensions` dictionary maps the names of
* dimensions defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1619; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_dimensions, __pyx_kp_s_The_dimensions_dictionary_maps_t) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1619; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1629, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_dimensions, __pyx_kp_s_The_dimensions_dictionary_maps_t) < 0)) __PYX_ERR(0, 1629, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1623
+ /* "netCDF4/_netCDF4.pyx":1633
* dimensions defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the
* `netCDF4.Dimension` class."""
* __pdoc__['Dataset.variables']=\ # <<<<<<<<<<<<<<
* """The `variables` dictionary maps the names of variables
* defined for this `netCDF4.Dataset` or `netCDF4.Group` to instances of the `netCDF4.Variable`
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_variables, __pyx_kp_s_The_variables_dictionary_maps_th) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1633, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_variables, __pyx_kp_s_The_variables_dictionary_maps_th) < 0)) __PYX_ERR(0, 1633, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1627
+ /* "netCDF4/_netCDF4.pyx":1637
* defined for this `netCDF4.Dataset` or `netCDF4.Group` to instances of the `netCDF4.Variable`
* class."""
* __pdoc__['Dataset.groups']=\ # <<<<<<<<<<<<<<
* """The groups dictionary maps the names of groups created for
* this `netCDF4.Dataset` or `netCDF4.Group` to instances of the `netCDF4.Group` class (the
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_groups, __pyx_kp_s_The_groups_dictionary_maps_the_n) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1627; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1637, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_groups, __pyx_kp_s_The_groups_dictionary_maps_the_n) < 0)) __PYX_ERR(0, 1637, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1632
+ /* "netCDF4/_netCDF4.pyx":1642
* `netCDF4.Dataset` class is simply a special case of the `netCDF4.Group` class which
* describes the root group in the netCDF4 file)."""
* __pdoc__['Dataset.cmptypes']=\ # <<<<<<<<<<<<<<
* """The `cmptypes` dictionary maps the names of
* compound types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_cmptypes, __pyx_kp_s_The_cmptypes_dictionary_maps_the) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1632; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1642, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_cmptypes, __pyx_kp_s_The_cmptypes_dictionary_maps_the) < 0)) __PYX_ERR(0, 1642, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1636
+ /* "netCDF4/_netCDF4.pyx":1646
* compound types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the
* `netCDF4.CompoundType` class."""
* __pdoc__['Dataset.vltypes']=\ # <<<<<<<<<<<<<<
* """The `vltypes` dictionary maps the names of
* variable-length types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_vltypes, __pyx_kp_s_The_vltypes_dictionary_maps_the) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1636; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1646, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_vltypes, __pyx_kp_s_The_vltypes_dictionary_maps_the) < 0)) __PYX_ERR(0, 1646, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1640
+ /* "netCDF4/_netCDF4.pyx":1650
* variable-length types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the
* `netCDF4.VLType` class."""
* __pdoc__['Dataset.enumtypes']=\ # <<<<<<<<<<<<<<
* """The `enumtypes` dictionary maps the names of
* Enum types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1640; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_enumtypes, __pyx_kp_s_The_enumtypes_dictionary_maps_th) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1640; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1650, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_enumtypes, __pyx_kp_s_The_enumtypes_dictionary_maps_th) < 0)) __PYX_ERR(0, 1650, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1644
+ /* "netCDF4/_netCDF4.pyx":1654
* Enum types defined for the `netCDF4.Group` or `netCDF4.Dataset` to instances of the
* `netCDF4.EnumType` class."""
* __pdoc__['Dataset.data_model']=\ # <<<<<<<<<<<<<<
* """`data_model` describes the netCDF
* data model version, one of `NETCDF3_CLASSIC`, `NETCDF4`,
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_data_model, __pyx_kp_s_data_model_describes_the_netCDF) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1644; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1654, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_data_model, __pyx_kp_s_data_model_describes_the_netCDF) < 0)) __PYX_ERR(0, 1654, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1648
+ /* "netCDF4/_netCDF4.pyx":1658
* data model version, one of `NETCDF3_CLASSIC`, `NETCDF4`,
* `NETCDF4_CLASSIC`, `NETCDF3_64BIT_OFFSET` or `NETCDF3_64BIT_DATA`."""
* __pdoc__['Dataset.file_format']=\ # <<<<<<<<<<<<<<
* """same as `data_model`, retained for backwards compatibility."""
* __pdoc__['Dataset.disk_format']=\
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1648; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_file_format, __pyx_kp_s_same_as_data_model_retained_for) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1648; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1658, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_file_format, __pyx_kp_s_same_as_data_model_retained_for) < 0)) __PYX_ERR(0, 1658, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1650
+ /* "netCDF4/_netCDF4.pyx":1660
* __pdoc__['Dataset.file_format']=\
* """same as `data_model`, retained for backwards compatibility."""
* __pdoc__['Dataset.disk_format']=\ # <<<<<<<<<<<<<<
* """`disk_format` describes the underlying
* file format, one of `NETCDF3`, `HDF5`, `HDF4`,
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_disk_format, __pyx_kp_s_disk_format_describes_the_under) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1650; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1660, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_disk_format, __pyx_kp_s_disk_format_describes_the_under) < 0)) __PYX_ERR(0, 1660, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1656
+ /* "netCDF4/_netCDF4.pyx":1666
* netcdf C library version >= 4.3.1, otherwise will always return
* `UNDEFINED`."""
* __pdoc__['Dataset.parent']=\ # <<<<<<<<<<<<<<
* """`parent` is a reference to the parent
* `netCDF4.Group` instance. `None` for the root group or `netCDF4.Dataset` instance"""
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1656; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_parent, __pyx_kp_s_parent_is_a_reference_to_the_pa) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1656; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1666, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_parent, __pyx_kp_s_parent_is_a_reference_to_the_pa) < 0)) __PYX_ERR(0, 1666, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1659
+ /* "netCDF4/_netCDF4.pyx":1669
* """`parent` is a reference to the parent
* `netCDF4.Group` instance. `None` for the root group or `netCDF4.Dataset` instance"""
* __pdoc__['Dataset.path']=\ # <<<<<<<<<<<<<<
* """`path` shows the location of the `netCDF4.Group` in
* the `netCDF4.Dataset` in a unix directory format (the names of groups in the
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_path, __pyx_kp_s_path_shows_the_location_of_the) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1659; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1669, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_path, __pyx_kp_s_path_shows_the_location_of_the) < 0)) __PYX_ERR(0, 1669, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":1664
+ /* "netCDF4/_netCDF4.pyx":1674
* hierarchy separated by backslashes). A `netCDF4.Dataset` instance is the root
* group, so the path is simply `'/'`."""
* __pdoc__['Dataset.keepweakref']=\ # <<<<<<<<<<<<<<
* """If `True`, child Dimension and Variables objects only keep weak references to
* the parent Dataset or Group."""
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1664; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dataset_keepweakref, __pyx_kp_s_If_True_child_Dimension_and_Vari) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1664; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1674, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dataset_keepweakref, __pyx_kp_s_If_True_child_Dimension_and_Vari) < 0)) __PYX_ERR(0, 1674, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2557
+ /* "netCDF4/_netCDF4.pyx":2567
* """
* # Docstrings for class variables (used by pdoc).
* __pdoc__['Group.name']=\ # <<<<<<<<<<<<<<
* """A string describing the name of the `netCDF4.Group`."""
* def __init__(self, parent, name, **kwargs):
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2557; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Group_name, __pyx_kp_s_A_string_describing_the_name_of) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2557; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2567, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Group_name, __pyx_kp_s_A_string_describing_the_name_of) < 0)) __PYX_ERR(0, 2567, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2656
+ /* "netCDF4/_netCDF4.pyx":2666
* cdef public _data_model, _name, _grp
* # Docstrings for class variables (used by pdoc).
* __pdoc__['Dimension.name']=\ # <<<<<<<<<<<<<<
* """A string describing the name of the `netCDF4.Dimension` - used when creating a
* `netCDF4.Variable` instance with `netCDF4.Dataset.createVariable`."""
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2656; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Dimension_name, __pyx_kp_s_A_string_describing_the_name_of_2) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2656; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2666, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Dimension_name, __pyx_kp_s_A_string_describing_the_name_of_2) < 0)) __PYX_ERR(0, 2666, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2852
+ /* "netCDF4/_netCDF4.pyx":2862
* __orthogonal_indexing__, _has_lsd
* # Docstrings for class variables (used by pdoc).
* __pdoc__['Variable.dimensions'] = \ # <<<<<<<<<<<<<<
* """A tuple containing the names of the
* dimensions associated with this variable."""
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_dimensions, __pyx_kp_s_A_tuple_containing_the_names_of) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2862, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_dimensions, __pyx_kp_s_A_tuple_containing_the_names_of) < 0)) __PYX_ERR(0, 2862, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2855
+ /* "netCDF4/_netCDF4.pyx":2865
* """A tuple containing the names of the
* dimensions associated with this variable."""
* __pdoc__['Variable.dtype'] = \ # <<<<<<<<<<<<<<
* """A numpy dtype object describing the
* variable's data type."""
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2855; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_dtype, __pyx_kp_s_A_numpy_dtype_object_describing) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2855; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2865, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_dtype, __pyx_kp_s_A_numpy_dtype_object_describing) < 0)) __PYX_ERR(0, 2865, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2858
+ /* "netCDF4/_netCDF4.pyx":2868
* """A numpy dtype object describing the
* variable's data type."""
* __pdoc__['Variable.ndim'] = \ # <<<<<<<<<<<<<<
* """The number of variable dimensions."""
* __pdoc__['Variable.scale'] = \
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2858; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_ndim, __pyx_kp_s_The_number_of_variable_dimension) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2858; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2868, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_ndim, __pyx_kp_s_The_number_of_variable_dimension) < 0)) __PYX_ERR(0, 2868, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2860
+ /* "netCDF4/_netCDF4.pyx":2870
* __pdoc__['Variable.ndim'] = \
* """The number of variable dimensions."""
* __pdoc__['Variable.scale'] = \ # <<<<<<<<<<<<<<
* """if True, `scale_factor` and `add_offset` are
* applied. Default is `True`, can be reset using `netCDF4.Variable.set_auto_scale` and
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2860; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_scale, __pyx_kp_s_if_True_scale_factor_and_add_off) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2860; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2870, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_scale, __pyx_kp_s_if_True_scale_factor_and_add_off) < 0)) __PYX_ERR(0, 2870, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2864
+ /* "netCDF4/_netCDF4.pyx":2874
* applied. Default is `True`, can be reset using `netCDF4.Variable.set_auto_scale` and
* `netCDF4.Variable.set_auto_maskandscale` methods."""
* __pdoc__['Variable.mask'] = \ # <<<<<<<<<<<<<<
* """If True, data is automatically converted to/from masked
* arrays when missing values or fill values are present. Default is `True`, can be
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_mask, __pyx_kp_s_If_True_data_is_automatically_co) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2874, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_mask, __pyx_kp_s_If_True_data_is_automatically_co) < 0)) __PYX_ERR(0, 2874, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2869
+ /* "netCDF4/_netCDF4.pyx":2879
* reset using `netCDF4.Variable.set_auto_mask` and `netCDF4.Variable.set_auto_maskandscale`
* methods."""
* __pdoc__['Variable.least_significant_digit'] = \ # <<<<<<<<<<<<<<
* """Describes the power of ten of the
* smallest decimal place in the data the contains a reliable value. Data is
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2869; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_least_significant_digit, __pyx_kp_s_Describes_the_power_of_ten_of_th) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2869; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2879, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_least_significant_digit, __pyx_kp_s_Describes_the_power_of_ten_of_th) < 0)) __PYX_ERR(0, 2879, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2874
+ /* "netCDF4/_netCDF4.pyx":2884
* truncated to this decimal place when it is assigned to the `netCDF4.Variable`
* instance. If `None`, the data is not truncated."""
* __pdoc__['Variable.__orthogonal_indexing__'] = \ # <<<<<<<<<<<<<<
* """Always `True`. Indicates to client code
* that the object supports 'orthogonal indexing', which means that slices
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2874; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable___orthogonal_indexing, __pyx_kp_s_Always_True_Indicates_to_client) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2874; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2884, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable___orthogonal_indexing, __pyx_kp_s_Always_True_Indicates_to_client) < 0)) __PYX_ERR(0, 2884, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2879
+ /* "netCDF4/_netCDF4.pyx":2889
* that are 1d arrays or lists slice along each dimension independently. This
* behavior is similar to Fortran or Matlab, but different than numpy."""
* __pdoc__['Variable.datatype'] = \ # <<<<<<<<<<<<<<
* """numpy data type (for primitive data types) or
* VLType/CompoundType/EnumType instance (for compound, vlen or enum
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2879; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_datatype, __pyx_kp_s_numpy_data_type_for_primitive_da_2) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2879; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2889, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_datatype, __pyx_kp_s_numpy_data_type_for_primitive_da) < 0)) __PYX_ERR(0, 2889, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2883
+ /* "netCDF4/_netCDF4.pyx":2893
* VLType/CompoundType/EnumType instance (for compound, vlen or enum
* data types)."""
* __pdoc__['Variable.name'] = \ # <<<<<<<<<<<<<<
* """String name."""
* __pdoc__['Variable.shape'] = \
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2883; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_name, __pyx_kp_s_String_name) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2883; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2893, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_name, __pyx_kp_s_String_name) < 0)) __PYX_ERR(0, 2893, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2885
+ /* "netCDF4/_netCDF4.pyx":2895
* __pdoc__['Variable.name'] = \
* """String name."""
* __pdoc__['Variable.shape'] = \ # <<<<<<<<<<<<<<
* """A tuple with the current shape (length of all dimensions)."""
* __pdoc__['Variable.size'] = \
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2885; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_shape, __pyx_kp_s_A_tuple_with_the_current_shape_l) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2885; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2895, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_shape, __pyx_kp_s_A_tuple_with_the_current_shape_l) < 0)) __PYX_ERR(0, 2895, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
- /* "netCDF4/_netCDF4.pyx":2887
+ /* "netCDF4/_netCDF4.pyx":2897
* __pdoc__['Variable.shape'] = \
* """A tuple with the current shape (length of all dimensions)."""
* __pdoc__['Variable.size'] = \ # <<<<<<<<<<<<<<
* """The number of stored elements."""
*
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2887; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_Variable_size, __pyx_kp_s_The_number_of_stored_elements) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 2887; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 2897, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_Variable_size, __pyx_kp_s_The_number_of_stored_elements) < 0)) __PYX_ERR(0, 2897, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4478
* cdef public nc_type _nc_type
@@ -78313,10 +77617,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """String name."""
* __pdoc__['CompoundType.dtype'] = \
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_CompoundType_name, __pyx_kp_s_String_name) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4478; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4478, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_CompoundType_name, __pyx_kp_s_String_name) < 0)) __PYX_ERR(0, 4478, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4480
* __pdoc__['CompoundType.name'] = \
@@ -78325,10 +77629,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """A numpy dtype object describing the compound data type."""
* def __init__(self, grp, object dt, object dtype_name, **kwargs):
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_CompoundType_dtype, __pyx_kp_s_A_numpy_dtype_object_describing_2) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4480; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4480, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_CompoundType_dtype, __pyx_kp_s_A_numpy_dtype_object_describing_2) < 0)) __PYX_ERR(0, 4480, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4722
* cdef public nc_type _nc_type
@@ -78337,10 +77641,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """String name."""
* __pdoc__['VLType.dtype'] = \
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4722; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_VLType_name, __pyx_kp_s_String_name) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4722; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4722, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_VLType_name, __pyx_kp_s_String_name) < 0)) __PYX_ERR(0, 4722, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4724
* __pdoc__['VLType.name'] = \
@@ -78349,10 +77653,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """A numpy dtype object describing the component type for the VLEN."""
* def __init__(self, grp, object dt, object dtype_name, **kwargs):
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4724; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_VLType_dtype, __pyx_kp_s_A_numpy_dtype_object_describing_3) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4724; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4724, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_VLType_dtype, __pyx_kp_s_A_numpy_dtype_object_describing_3) < 0)) __PYX_ERR(0, 4724, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4836
* cdef public nc_type _nc_type
@@ -78361,10 +77665,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """String name."""
* __pdoc__['EnumType.dtype'] = \
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4836; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_EnumType_name, __pyx_kp_s_String_name) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4836; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4836, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_EnumType_name, __pyx_kp_s_String_name) < 0)) __PYX_ERR(0, 4836, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4838
* __pdoc__['EnumType.name'] = \
@@ -78373,10 +77677,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """A numpy integer dtype object describing the base type for the Enum."""
* __pdoc__['EnumType.enum_dict'] = \
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_EnumType_dtype, __pyx_kp_s_A_numpy_integer_dtype_object_des) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4838; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4838, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_EnumType_dtype, __pyx_kp_s_A_numpy_integer_dtype_object_des) < 0)) __PYX_ERR(0, 4838, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4840
* __pdoc__['EnumType.dtype'] = \
@@ -78385,10 +77689,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """A python dictionary describing the enum fields and values."""
* def __init__(self, grp, object dt, object dtype_name, object enum_dict, **kwargs):
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (unlikely(PyObject_SetItem(__pyx_t_2, __pyx_kp_s_EnumType_enum_dict, __pyx_kp_s_A_python_dictionary_describing_t) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4840; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_pdoc); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4840, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (unlikely(PyObject_SetItem(__pyx_t_11, __pyx_kp_s_EnumType_enum_dict, __pyx_kp_s_A_python_dictionary_describing_t) < 0)) __PYX_ERR(0, 4840, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4960
* return pystr # already bytes or unicode?
@@ -78397,10 +77701,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* # encode a byte string to an ascii encoded string.
* if python3:
*/
- __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_7_to_ascii, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_to_ascii, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4960; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_7_to_ascii, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4960, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_to_ascii, __pyx_t_11) < 0) __PYX_ERR(0, 4960, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4970
* # extra utilities (formerly in utils.pyx)
@@ -78409,33 +77713,33 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* from netcdftime import _parse_date, microsec_units, millisec_units,\
* sec_units, min_units, hr_units, day_units
*/
- __pyx_t_2 = PyList_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_11 = PyList_New(3); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4970, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
__Pyx_INCREF(__pyx_n_s_timedelta);
__Pyx_GIVEREF(__pyx_n_s_timedelta);
- PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_timedelta);
+ PyList_SET_ITEM(__pyx_t_11, 0, __pyx_n_s_timedelta);
__Pyx_INCREF(__pyx_n_s_datetime);
__Pyx_GIVEREF(__pyx_n_s_datetime);
- PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_datetime);
+ PyList_SET_ITEM(__pyx_t_11, 1, __pyx_n_s_datetime);
__Pyx_INCREF(__pyx_n_s_MINYEAR);
__Pyx_GIVEREF(__pyx_n_s_MINYEAR);
- PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_MINYEAR);
- __pyx_t_7 = __Pyx_Import(__pyx_n_s_datetime, __pyx_t_2, -1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_7, __pyx_n_s_timedelta); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_timedelta, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_7, __pyx_n_s_datetime); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_datetime, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_7, __pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyList_SET_ITEM(__pyx_t_11, 2, __pyx_n_s_MINYEAR);
+ __pyx_t_2 = __Pyx_Import(__pyx_n_s_datetime, __pyx_t_11, -1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4970, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINYEAR, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4970; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_11 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_timedelta); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4970, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_timedelta, __pyx_t_11) < 0) __PYX_ERR(0, 4970, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_11 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_datetime); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4970, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_datetime, __pyx_t_11) < 0) __PYX_ERR(0, 4970, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ __pyx_t_11 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_MINYEAR); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4970, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_MINYEAR, __pyx_t_11) < 0) __PYX_ERR(0, 4970, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":4971
* #----------------------------------------
@@ -78444,61 +77748,61 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* sec_units, min_units, hr_units, day_units
*
*/
- __pyx_t_7 = PyList_New(7); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = PyList_New(7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_n_s_parse_date);
__Pyx_GIVEREF(__pyx_n_s_parse_date);
- PyList_SET_ITEM(__pyx_t_7, 0, __pyx_n_s_parse_date);
+ PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_parse_date);
__Pyx_INCREF(__pyx_n_s_microsec_units);
__Pyx_GIVEREF(__pyx_n_s_microsec_units);
- PyList_SET_ITEM(__pyx_t_7, 1, __pyx_n_s_microsec_units);
+ PyList_SET_ITEM(__pyx_t_2, 1, __pyx_n_s_microsec_units);
__Pyx_INCREF(__pyx_n_s_millisec_units);
__Pyx_GIVEREF(__pyx_n_s_millisec_units);
- PyList_SET_ITEM(__pyx_t_7, 2, __pyx_n_s_millisec_units);
+ PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_millisec_units);
__Pyx_INCREF(__pyx_n_s_sec_units);
__Pyx_GIVEREF(__pyx_n_s_sec_units);
- PyList_SET_ITEM(__pyx_t_7, 3, __pyx_n_s_sec_units);
+ PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_sec_units);
__Pyx_INCREF(__pyx_n_s_min_units);
__Pyx_GIVEREF(__pyx_n_s_min_units);
- PyList_SET_ITEM(__pyx_t_7, 4, __pyx_n_s_min_units);
+ PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_min_units);
__Pyx_INCREF(__pyx_n_s_hr_units);
__Pyx_GIVEREF(__pyx_n_s_hr_units);
- PyList_SET_ITEM(__pyx_t_7, 5, __pyx_n_s_hr_units);
+ PyList_SET_ITEM(__pyx_t_2, 5, __pyx_n_s_hr_units);
__Pyx_INCREF(__pyx_n_s_day_units);
__Pyx_GIVEREF(__pyx_n_s_day_units);
- PyList_SET_ITEM(__pyx_t_7, 6, __pyx_n_s_day_units);
- __pyx_t_2 = __Pyx_Import(__pyx_n_s_netcdftime, __pyx_t_7, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyList_SET_ITEM(__pyx_t_2, 6, __pyx_n_s_day_units);
+ __pyx_t_11 = __Pyx_Import(__pyx_n_s_netcdftime, __pyx_t_2, -1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_11, __pyx_n_s_parse_date); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4971, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_parse_date); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_parse_date, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_microsec_units); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_microsec_units, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_millisec_units); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_millisec_units, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_sec_units); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_sec_units, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4972; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_min_units); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_min_units, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4972; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_hr_units); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_hr_units, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4972; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_day_units); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4971; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_day_units, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4972; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_parse_date, __pyx_t_2) < 0) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_11, __pyx_n_s_microsec_units); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_microsec_units, __pyx_t_2) < 0) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_11, __pyx_n_s_millisec_units); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_millisec_units, __pyx_t_2) < 0) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_11, __pyx_n_s_sec_units); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_sec_units, __pyx_t_2) < 0) __PYX_ERR(0, 4972, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_11, __pyx_n_s_min_units); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_min_units, __pyx_t_2) < 0) __PYX_ERR(0, 4972, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_11, __pyx_n_s_hr_units); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_hr_units, __pyx_t_2) < 0) __PYX_ERR(0, 4972, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_11, __pyx_n_s_day_units); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4971, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_day_units, __pyx_t_2) < 0) __PYX_ERR(0, 4972, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":4975
*
@@ -78507,13 +77811,13 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
*
* def _dateparse(timestr):
*/
- __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = __Pyx_GetModuleGlobalName(__pyx_n_s_datetime); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4975, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_tuple__134, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4975, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__139, NULL); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_gregorian, __pyx_t_2) < 0) __PYX_ERR(0, 4975, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_gregorian, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4975; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":4977
* gregorian = datetime(1582,10,15)
@@ -78522,10 +77826,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """parse a string of the form time-units since yyyy-mm-dd hh:mm:ss,
* return a datetime instance"""
*/
- __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_dateparse, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_dateparse, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4977; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_dateparse, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4977, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_dateparse, __pyx_t_2) < 0) __PYX_ERR(0, 4977, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5002
* return basedate
@@ -78534,10 +77838,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`stringtoarr(a, NUMCHARS,dtype='S')`**
*/
- __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_11stringtoarr, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_stringtoarr, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5002; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_11stringtoarr, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5002, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_stringtoarr, __pyx_t_2) < 0) __PYX_ERR(0, 5002, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5025
* return arr
@@ -78546,10 +77850,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`stringtochar(a)`**
*/
- __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_13stringtochar, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_stringtochar, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5025; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_13stringtochar, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5025, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_stringtochar, __pyx_t_2) < 0) __PYX_ERR(0, 5025, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5044
* return b
@@ -78558,10 +77862,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`chartostring(b)`**
*/
- __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_15chartostring, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_chartostring, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5044; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_15chartostring, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5044, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_chartostring, __pyx_t_2) < 0) __PYX_ERR(0, 5044, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5065
* return a
@@ -78570,10 +77874,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`date2num(dates,units,calendar='standard')`**
*/
- __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_17date2num, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5065; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_date2num, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5065; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_17date2num, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5065, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_date2num, __pyx_t_2) < 0) __PYX_ERR(0, 5065, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5153
* return cdftime.date2num(dates)
@@ -78582,10 +77886,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`num2date(times,units,calendar='standard')`**
*/
- __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_19num2date, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5153; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_num2date, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5153; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_19num2date, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5153, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_num2date, __pyx_t_2) < 0) __PYX_ERR(0, 5153, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5256
* return cdftime.num2date(times)
@@ -78594,10 +77898,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`date2index(dates, nctime, calendar=None, select='exact')`**
*/
- __pyx_t_7 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_21date2index, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_date2index, __pyx_t_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5256; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_21date2index, NULL, __pyx_n_s_netCDF4__netCDF4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5256, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_date2index, __pyx_t_2) < 0) __PYX_ERR(0, 5256, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "netCDF4/_netCDF4.pyx":5312
* return netcdftime.date2index(dates, nctime, calendar, select)
@@ -78606,14 +77910,14 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* Class for reading multi-file netCDF Datasets, making variables
*/
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5312, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset));
__Pyx_GIVEREF(((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset));
- PyTuple_SET_ITEM(__pyx_t_7, 0, ((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset));
- __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_7, __pyx_n_s_MFDataset, __pyx_n_s_MFDataset, (PyObject *) NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_kp_s_Class_for_reading_multi_file_ne); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_ptype_7netCDF4_8_netCDF4_Dataset));
+ __pyx_t_11 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5312, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_11, __pyx_t_2, __pyx_n_s_MFDataset, __pyx_n_s_MFDataset, (PyObject *) NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_kp_s_Class_for_reading_multi_file_ne); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5312, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
/* "netCDF4/_netCDF4.pyx":5342
@@ -78623,17 +77927,17 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`__init__(self, files, check=False, aggdim=None, exclude=[])`**
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_1__init__, 0, __pyx_n_s_MFDataset___init, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__155)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_1__init__, 0, __pyx_n_s_MFDataset___init, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__150)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5342, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (!__Pyx_CyFunction_InitDefaults(__pyx_t_7, sizeof(__pyx_defaults), 1)) __PYX_ERR(0, 5342, __pyx_L1_error)
+ __pyx_t_13 = PyList_New(0); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 5342, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
- if (!__Pyx_CyFunction_InitDefaults(__pyx_t_13, sizeof(__pyx_defaults), 1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __pyx_t_11 = PyList_New(0); if (unlikely(!__pyx_t_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_11);
- __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_13)->__pyx_arg_exclude = __pyx_t_11;
- __Pyx_GIVEREF(__pyx_t_11);
- __pyx_t_11 = 0;
- __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_13, __pyx_pf_7netCDF4_8_netCDF4_9MFDataset_12__defaults__);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5342; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_7)->__pyx_arg_exclude = __pyx_t_13;
+ __Pyx_GIVEREF(__pyx_t_13);
+ __pyx_t_13 = 0;
+ __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_7, __pyx_pf_7netCDF4_8_netCDF4_9MFDataset_12__defaults__);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_7) < 0) __PYX_ERR(0, 5342, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5515
* self._path = '/'
@@ -78642,10 +77946,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """override base class attribute creation"""
* self.__dict__[name] = value
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_3__setattr__, 0, __pyx_n_s_MFDataset___setattr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__157)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5515; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_setattr, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5515; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_3__setattr__, 0, __pyx_n_s_MFDataset___setattr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__152)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5515, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_setattr, __pyx_t_7) < 0) __PYX_ERR(0, 5515, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5519
* self.__dict__[name] = value
@@ -78654,10 +77958,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* if name in ['variables','dimensions','file_format','groups',\
* 'data_model','disk_format','path']:
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_5__getattribute__, 0, __pyx_n_s_MFDataset___getattribute, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__159)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_getattribute, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5519; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_5__getattribute__, 0, __pyx_n_s_MFDataset___getattribute, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__154)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5519, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_getattribute, __pyx_t_7) < 0) __PYX_ERR(0, 5519, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5532
* return Dataset.__getattribute__(self, name)
@@ -78666,10 +77970,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`ncattrs(self)`**
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_7ncattrs, 0, __pyx_n_s_MFDataset_ncattrs, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__161)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5532; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_ncattrs, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5532; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_7ncattrs, 0, __pyx_n_s_MFDataset_ncattrs, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__156)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5532, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_ncattrs, __pyx_t_7) < 0) __PYX_ERR(0, 5532, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5540
* return self._cdf[0].__dict__.keys()
@@ -78678,10 +77982,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`close(self)`**
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_9close, 0, __pyx_n_s_MFDataset_close, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__163)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_close, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5540; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_9close, 0, __pyx_n_s_MFDataset_close, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__158)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5540, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_close, __pyx_t_7) < 0) __PYX_ERR(0, 5540, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5549
* dset.close()
@@ -78690,10 +77994,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* ncdump = ['%r\n' % type(self)]
* dimnames = tuple([str(dimname) for dimname in self.dimensions.keys()])
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_11__repr__, 0, __pyx_n_s_MFDataset___repr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__165)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_repr, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5549; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9MFDataset_11__repr__, 0, __pyx_n_s_MFDataset___repr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__160)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5549, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_repr, __pyx_t_7) < 0) __PYX_ERR(0, 5549, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5312
* return netcdftime.date2index(dates, nctime, calendar, select)
@@ -78702,13 +78006,13 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* Class for reading multi-file netCDF Datasets, making variables
*/
- __pyx_t_13 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_MFDataset, __pyx_t_7, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_MFDataset, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5312; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_11, __pyx_n_s_MFDataset, __pyx_t_2, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5312, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_MFDataset, __pyx_t_7) < 0) __PYX_ERR(0, 5312, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5567
* return ''.join(ncdump)
@@ -78717,14 +78021,14 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* def __init__(self, dimname, dim, dimlens, dimtotlen):
* self.dimlens = dimlens
*/
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5567, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_builtin_object);
__Pyx_GIVEREF(__pyx_builtin_object);
- PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_builtin_object);
- __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_7, __pyx_n_s_Dimension, __pyx_n_s_Dimension, (PyObject *) NULL, __pyx_n_s_netCDF4__netCDF4, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_object);
+ __pyx_t_11 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5567, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_11, __pyx_t_2, __pyx_n_s_Dimension, __pyx_n_s_Dimension, (PyObject *) NULL, __pyx_n_s_netCDF4__netCDF4, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5567, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
/* "netCDF4/_netCDF4.pyx":5568
@@ -78734,10 +78038,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* self.dimlens = dimlens
* self.dimtotlen = dimtotlen
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_10_Dimension_1__init__, 0, __pyx_n_s_Dimension___init, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__167)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5568; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_10_Dimension_1__init__, 0, __pyx_n_s_Dimension___init, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__162)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5568, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_7) < 0) __PYX_ERR(0, 5568, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5572
* self.dimtotlen = dimtotlen
@@ -78746,10 +78050,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* return self.dimtotlen
* def isunlimited(self):
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_10_Dimension_3__len__, 0, __pyx_n_s_Dimension___len, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__169)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5572; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_len, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5572; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_10_Dimension_3__len__, 0, __pyx_n_s_Dimension___len, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__164)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5572, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_len, __pyx_t_7) < 0) __PYX_ERR(0, 5572, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5574
* def __len__(self):
@@ -78758,10 +78062,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* return True
* def __repr__(self):
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_10_Dimension_5isunlimited, 0, __pyx_n_s_Dimension_isunlimited, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__171)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5574; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_isunlimited, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5574; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_10_Dimension_5isunlimited, 0, __pyx_n_s_Dimension_isunlimited, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__166)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5574, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_isunlimited, __pyx_t_7) < 0) __PYX_ERR(0, 5574, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5576
* def isunlimited(self):
@@ -78770,10 +78074,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* if self.isunlimited():
* return repr(type(self))+" (unlimited): name = '%s', size = %s\n" % (self._name,len(self))
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_10_Dimension_7__repr__, 0, __pyx_n_s_Dimension___repr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__173)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5576; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_repr, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5576; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_10_Dimension_7__repr__, 0, __pyx_n_s_Dimension___repr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__168)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5576, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_repr, __pyx_t_7) < 0) __PYX_ERR(0, 5576, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5567
* return ''.join(ncdump)
@@ -78782,13 +78086,13 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* def __init__(self, dimname, dim, dimlens, dimtotlen):
* self.dimlens = dimlens
*/
- __pyx_t_13 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_Dimension, __pyx_t_7, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_Dimension, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5567; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_11, __pyx_n_s_Dimension, __pyx_t_2, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5567, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_Dimension, __pyx_t_7) < 0) __PYX_ERR(0, 5567, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5582
* return repr(type(self))+": name = '%s', size = %s\n" % (self._name,len(self))
@@ -78797,14 +78101,14 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* def __init__(self, dset, varname, var, recdimname):
* self.dimensions = var.dimensions
*/
- __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5582; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
+ __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5582, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_builtin_object);
__Pyx_GIVEREF(__pyx_builtin_object);
- PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_builtin_object);
- __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5582; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_7, __pyx_n_s_Variable, __pyx_n_s_Variable, (PyObject *) NULL, __pyx_n_s_netCDF4__netCDF4, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5582; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_object);
+ __pyx_t_11 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5582, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_11, __pyx_t_2, __pyx_n_s_Variable, __pyx_n_s_Variable, (PyObject *) NULL, __pyx_n_s_netCDF4__netCDF4, (PyObject *) NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5582, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
/* "netCDF4/_netCDF4.pyx":5583
@@ -78814,10 +78118,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* self.dimensions = var.dimensions
* self._dset = dset
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_1__init__, 0, __pyx_n_s_Variable___init, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__175)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5583; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_1__init__, 0, __pyx_n_s_Variable___init, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__170)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5583, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_7) < 0) __PYX_ERR(0, 5583, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5596
* for name, value in var.__dict__.items():
@@ -78826,10 +78130,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* return self.dtype
* def ncattrs(self):
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_3typecode, 0, __pyx_n_s_Variable_typecode, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__177)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5596; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_typecode, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5596; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_3typecode, 0, __pyx_n_s_Variable_typecode, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__172)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5596, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_typecode, __pyx_t_7) < 0) __PYX_ERR(0, 5596, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5598
* def typecode(self):
@@ -78838,10 +78142,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* return self._mastervar.__dict__.keys()
* def __getattr__(self,name):
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_5ncattrs, 0, __pyx_n_s_Variable_ncattrs, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__179)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5598; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_ncattrs, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5598; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_5ncattrs, 0, __pyx_n_s_Variable_ncattrs, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__174)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5598, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_ncattrs, __pyx_t_7) < 0) __PYX_ERR(0, 5598, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5600
* def ncattrs(self):
@@ -78850,10 +78154,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* if name == 'shape': return self._shape()
* if name == 'ndim': return len(self._shape())
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_7__getattr__, 0, __pyx_n_s_Variable___getattr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__181)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5600; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_getattr, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5600; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_7__getattr__, 0, __pyx_n_s_Variable___getattr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__176)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5600, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_getattr, __pyx_t_7) < 0) __PYX_ERR(0, 5600, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5607
* except:
@@ -78862,10 +78166,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* ncdump_var = ['%r\n' % type(self)]
* dimnames = tuple([str(dimname) for dimname in self.dimensions])
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_9__repr__, 0, __pyx_n_s_Variable___repr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__183)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_repr, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5607; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_9__repr__, 0, __pyx_n_s_Variable___repr, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__178)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5607, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_repr, __pyx_t_7) < 0) __PYX_ERR(0, 5607, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5623
* ncdump_var.append('current size = %s\n' % repr(self.shape))
@@ -78874,10 +78178,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* if not self._shape:
* raise TypeError('len() of unsized object')
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_11__len__, 0, __pyx_n_s_Variable___len, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__185)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_len, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5623; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_11__len__, 0, __pyx_n_s_Variable___len, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__180)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5623, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_len, __pyx_t_7) < 0) __PYX_ERR(0, 5623, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5628
* else:
@@ -78886,10 +78190,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* recdimlen = len(self._dset.dimensions[self._recdimname])
* return (recdimlen,) + self._mastervar.shape[1:]
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_13_shape, 0, __pyx_n_s_Variable__shape, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__187)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5628; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_shape_2, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5628; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_13_shape, 0, __pyx_n_s_Variable__shape, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__182)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5628, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_shape_2, __pyx_t_7) < 0) __PYX_ERR(0, 5628, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5631
* recdimlen = len(self._dset.dimensions[self._recdimname])
@@ -78898,10 +78202,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* for v in self._recVar:
* v.set_auto_maskandscale(val)
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_15set_auto_maskandscale, 0, __pyx_n_s_Variable_set_auto_maskandscale, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__189)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5631; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_set_auto_maskandscale, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5631; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_15set_auto_maskandscale, 0, __pyx_n_s_Variable_set_auto_maskandscale, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__184)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5631, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_set_auto_maskandscale, __pyx_t_7) < 0) __PYX_ERR(0, 5631, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5634
* for v in self._recVar:
@@ -78910,10 +78214,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """Get records from a concatenated set of variables."""
*
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_17__getitem__, 0, __pyx_n_s_Variable___getitem, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__191)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5634; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_getitem, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5634; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_9_Variable_17__getitem__, 0, __pyx_n_s_Variable___getitem, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__186)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5634, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_getitem, __pyx_t_7) < 0) __PYX_ERR(0, 5634, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5582
* return repr(type(self))+": name = '%s', size = %s\n" % (self._name,len(self))
@@ -78922,13 +78226,13 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* def __init__(self, dset, varname, var, recdimname):
* self.dimensions = var.dimensions
*/
- __pyx_t_13 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_Variable, __pyx_t_7, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5582; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_Variable, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5582; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_11, __pyx_n_s_Variable, __pyx_t_2, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5582, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_Variable, __pyx_t_7) < 0) __PYX_ERR(0, 5582, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
- __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5738
*
@@ -78937,16 +78241,16 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* Class providing an interface to a MFDataset time Variable by imposing a unique common
*/
- __pyx_t_7 = __Pyx_GetModuleGlobalName(__pyx_n_s_Variable); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_Variable); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5738, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
- __Pyx_GIVEREF(__pyx_t_7);
- PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_7);
- __pyx_t_7 = 0;
- __pyx_t_7 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_7);
- __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_7, __pyx_t_2, __pyx_n_s_MFTime, __pyx_n_s_MFTime, (PyObject *) NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_kp_s_Class_providing_an_interface_to); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
+ __pyx_t_11 = PyTuple_New(1); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5738, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_2);
+ __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_CalculateMetaclass(NULL, __pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5738, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_1 = __Pyx_Py3MetaclassPrepare(__pyx_t_2, __pyx_t_11, __pyx_n_s_MFTime, __pyx_n_s_MFTime, (PyObject *) NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_kp_s_Class_providing_an_interface_to); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5738, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
/* "netCDF4/_netCDF4.pyx":5773
@@ -78956,11 +78260,11 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* **`__init__(self, time, units=None)`**
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_6MFTime_1__init__, 0, __pyx_n_s_MFTime___init, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__193)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_13, __pyx_tuple__194);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5773; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_6MFTime_1__init__, 0, __pyx_n_s_MFTime___init, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__188)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5773, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_7, __pyx_tuple__189);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_init, __pyx_t_7) < 0) __PYX_ERR(0, 5773, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5821
*
@@ -78968,10 +78272,10 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* def __getitem__(self, elem): # <<<<<<<<<<<<<<
* return self.__time[elem] + self.__delta[elem]
*/
- __pyx_t_13 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_6MFTime_3__getitem__, 0, __pyx_n_s_MFTime___getitem, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__196)); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5821; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_getitem, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5821; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
+ __pyx_t_7 = __Pyx_CyFunction_NewEx(&__pyx_mdef_7netCDF4_8_netCDF4_6MFTime_3__getitem__, 0, __pyx_n_s_MFTime___getitem, NULL, __pyx_n_s_netCDF4__netCDF4, __pyx_d, ((PyObject *)__pyx_codeobj__191)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5821, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyObject_SetItem(__pyx_t_1, __pyx_n_s_getitem, __pyx_t_7) < 0) __PYX_ERR(0, 5821, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "netCDF4/_netCDF4.pyx":5738
*
@@ -78980,24 +78284,24 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
* """
* Class providing an interface to a MFDataset time Variable by imposing a unique common
*/
- __pyx_t_13 = __Pyx_Py3ClassCreate(__pyx_t_7, __pyx_n_s_MFTime, __pyx_t_2, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_13);
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_MFTime, __pyx_t_13) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5738; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
- __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_7 = __Pyx_Py3ClassCreate(__pyx_t_2, __pyx_n_s_MFTime, __pyx_t_11, __pyx_t_1, NULL, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5738, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_MFTime, __pyx_t_7) < 0) __PYX_ERR(0, 5738, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "netCDF4/_netCDF4.pyx":1
* """ # <<<<<<<<<<<<<<
- * Version 1.2.3
+ * Version 1.2.4
* -------------
*/
- __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_GOTREF(__pyx_t_2);
- if (PyDict_SetItem(__pyx_t_2, __pyx_kp_u_Dataset_get_variables_by_attribu, __pyx_kp_u_get_variables_by_attribute_self) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}
- __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_11 = PyDict_New(); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ if (PyDict_SetItem(__pyx_t_11, __pyx_kp_u_Dataset_get_variables_by_attribu, __pyx_kp_u_get_variables_by_attribute_self) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_11) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/*--- Wrapped vars code ---*/
@@ -79028,6 +78332,7 @@ PyMODINIT_FUNC PyInit__netCDF4(void)
}
/* --- Runtime support code --- */
+/* Refnanny */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
PyObject *m = NULL, *p = NULL;
@@ -79044,6 +78349,7 @@ end:
}
#endif
+/* GetBuiltinName */
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
if (unlikely(!result)) {
@@ -79057,6 +78363,7 @@ static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
return result;
}
+/* IterFinish */
static CYTHON_INLINE int __Pyx_IterFinish(void) {
#if CYTHON_COMPILING_IN_CPYTHON
PyThreadState *tstate = PyThreadState_GET();
@@ -79091,6 +78398,7 @@ static CYTHON_INLINE int __Pyx_IterFinish(void) {
#endif
}
+/* PyObjectCall */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
PyObject *result;
@@ -79110,6 +78418,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg
}
#endif
+/* PyObjectCallMethO */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
PyObject *self, *result;
@@ -79129,6 +78438,7 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject
}
#endif
+/* PyObjectCallNoArg */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
#ifdef __Pyx_CyFunction_USED
@@ -79144,7 +78454,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
}
#endif
-#if CYTHON_COMPILING_IN_CPYTHON
+/* PyObjectCallOneArg */
+ #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
PyObject *result;
PyObject *args = PyTuple_New(1);
@@ -79178,7 +78489,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObjec
}
#endif
-static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
+/* PyObjectCallMethod0 */
+ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
PyObject *method, *result = NULL;
method = __Pyx_PyObject_GetAttrStr(obj, method_name);
if (unlikely(!method)) goto bad;
@@ -79199,18 +78511,21 @@ bad:
return result;
}
-static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
+/* RaiseNeedMoreValuesToUnpack */
+ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
PyErr_Format(PyExc_ValueError,
"need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
index, (index == 1) ? "" : "s");
}
-static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
+/* RaiseTooManyValuesToUnpack */
+ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
PyErr_Format(PyExc_ValueError,
"too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
}
-static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
+/* UnpackItemEndCheck */
+ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
if (unlikely(retval)) {
Py_DECREF(retval);
__Pyx_RaiseTooManyValuesError(expected);
@@ -79221,11 +78536,13 @@ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
return 0;
}
-static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
+/* RaiseNoneIterError */
+ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}
-static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
+/* UnpackTupleError */
+ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
if (t == Py_None) {
__Pyx_RaiseNoneNotIterableError();
} else if (PyTuple_GET_SIZE(t) < index) {
@@ -79235,7 +78552,8 @@ static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
}
}
-static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
+/* UnpackTuple2 */
+ static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
int is_tuple, int has_known_size, int decref_tuple) {
Py_ssize_t index;
PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
@@ -79281,7 +78599,8 @@ bad:
return -1;
}
-static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
+/* dict_iter */
+ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
Py_ssize_t* p_orig_length, int* p_source_is_dict) {
is_dict = is_dict || likely(PyDict_CheckExact(iterable));
*p_source_is_dict = is_dict;
@@ -79376,7 +78695,8 @@ static CYTHON_INLINE int __Pyx_dict_iter_next(
return 1;
}
-static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
+/* GetModuleGlobalName */
+ static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
PyObject *result;
#if CYTHON_COMPILING_IN_CPYTHON
result = PyDict_GetItem(__pyx_d, name);
@@ -79393,7 +78713,8 @@ static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
return result;
}
-static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
+/* decode_c_string */
+ static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
const char* cstring, Py_ssize_t start, Py_ssize_t stop,
const char* encoding, const char* errors,
PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
@@ -79425,10 +78746,10 @@ static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
}
}
-static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) {
-#if CYTHON_COMPILING_IN_CPYTHON
+/* PyErrFetchRestore */
+ #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
PyObject *tmp_type, *tmp_value, *tmp_tb;
- PyThreadState *tstate = PyThreadState_GET();
tmp_type = tstate->curexc_type;
tmp_value = tstate->curexc_value;
tmp_tb = tstate->curexc_traceback;
@@ -79438,27 +78759,22 @@ static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyOb
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
-#else
- PyErr_Restore(type, value, tb);
-#endif
}
-static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) {
-#if CYTHON_COMPILING_IN_CPYTHON
- PyThreadState *tstate = PyThreadState_GET();
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
*type = tstate->curexc_type;
*value = tstate->curexc_value;
*tb = tstate->curexc_traceback;
tstate->curexc_type = 0;
tstate->curexc_value = 0;
tstate->curexc_traceback = 0;
-#else
- PyErr_Fetch(type, value, tb);
-#endif
}
+#endif
-#if PY_MAJOR_VERSION < 3
+/* RaiseException */
+ #if PY_MAJOR_VERSION < 3
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
CYTHON_UNUSED PyObject *cause) {
+ __Pyx_PyThreadState_declare
Py_XINCREF(type);
if (!value || value == Py_None)
value = NULL;
@@ -79497,6 +78813,7 @@ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
goto raise_error;
}
}
+ __Pyx_PyThreadState_assign
__Pyx_ErrRestore(type, value, tb);
return;
raise_error:
@@ -79616,7 +78933,8 @@ bad:
}
#endif
-static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
+/* ExtTypeTest */
+ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
if (unlikely(!type)) {
PyErr_SetString(PyExc_SystemError, "Missing type object");
return 0;
@@ -79628,7 +78946,8 @@ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
return 0;
}
-static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
+/* BytesEquals */
+ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) {
#if CYTHON_COMPILING_IN_PYPY
return PyObject_RichCompareBool(s1, s2, equals);
#else
@@ -79665,7 +78984,8 @@ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int eq
#endif
}
-static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
+/* UnicodeEquals */
+ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) {
#if CYTHON_COMPILING_IN_PYPY
return PyObject_RichCompareBool(s1, s2, equals);
#else
@@ -79748,7 +79068,8 @@ return_ne:
#endif
}
-static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
+/* GetItemInt */
+ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
PyObject *r;
if (!j) return NULL;
r = PyObject_GetItem(o, j);
@@ -79812,10 +79133,9 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
if (likely(l >= 0)) {
i += l;
} else {
- if (PyErr_ExceptionMatches(PyExc_OverflowError))
- PyErr_Clear();
- else
+ if (!PyErr_ExceptionMatches(PyExc_OverflowError))
return NULL;
+ PyErr_Clear();
}
}
return m->sq_item(o, i);
@@ -79829,23 +79149,18 @@ static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
}
-static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) {
-#if CYTHON_COMPILING_IN_CPYTHON
- PyThreadState *tstate = PyThreadState_GET();
+/* SaveResetException */
+ #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
*type = tstate->exc_type;
*value = tstate->exc_value;
*tb = tstate->exc_traceback;
Py_XINCREF(*type);
Py_XINCREF(*value);
Py_XINCREF(*tb);
-#else
- PyErr_GetExcInfo(type, value, tb);
-#endif
}
-static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) {
-#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
PyObject *tmp_type, *tmp_value, *tmp_tb;
- PyThreadState *tstate = PyThreadState_GET();
tmp_type = tstate->exc_type;
tmp_value = tstate->exc_value;
tmp_tb = tstate->exc_traceback;
@@ -79855,16 +79170,28 @@ static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb)
Py_XDECREF(tmp_type);
Py_XDECREF(tmp_value);
Py_XDECREF(tmp_tb);
-#else
- PyErr_SetExcInfo(type, value, tb);
+}
#endif
+
+/* PyErrExceptionMatches */
+ #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+ PyObject *exc_type = tstate->curexc_type;
+ if (exc_type == err) return 1;
+ if (unlikely(!exc_type)) return 0;
+ return PyErr_GivenExceptionMatches(exc_type, err);
}
+#endif
+/* GetException */
+ #if CYTHON_COMPILING_IN_CPYTHON
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
+#endif
PyObject *local_type, *local_value, *local_tb;
#if CYTHON_COMPILING_IN_CPYTHON
PyObject *tmp_type, *tmp_value, *tmp_tb;
- PyThreadState *tstate = PyThreadState_GET();
local_type = tstate->curexc_type;
local_value = tstate->curexc_value;
local_tb = tstate->curexc_traceback;
@@ -79917,7 +79244,8 @@ bad:
return -1;
}
-static void __Pyx_RaiseDoubleKeywordsError(
+/* RaiseDoubleKeywords */
+ static void __Pyx_RaiseDoubleKeywordsError(
const char* func_name,
PyObject* kw_name)
{
@@ -79930,7 +79258,8 @@ static void __Pyx_RaiseDoubleKeywordsError(
#endif
}
-static int __Pyx_ParseOptionalKeywords(
+/* ParseKeywords */
+ static int __Pyx_ParseOptionalKeywords(
PyObject *kwds,
PyObject **argnames[],
PyObject *kwds2,
@@ -80031,7 +79360,8 @@ bad:
return -1;
}
-static void __Pyx_RaiseArgtupleInvalid(
+/* RaiseArgTupleInvalid */
+ static void __Pyx_RaiseArgtupleInvalid(
const char* func_name,
int exact,
Py_ssize_t num_min,
@@ -80056,7 +79386,8 @@ static void __Pyx_RaiseArgtupleInvalid(
(num_expected == 1) ? "" : "s", num_found);
}
-static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
+/* SliceObject */
+ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
Py_ssize_t cstart, Py_ssize_t cstop,
PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {
@@ -80091,10 +79422,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj,
if (cstart < 0) cstart = 0;
}
} else {
- if (PyErr_ExceptionMatches(PyExc_OverflowError))
- PyErr_Clear();
- else
+ if (!PyErr_ExceptionMatches(PyExc_OverflowError))
goto bad;
+ PyErr_Clear();
}
}
return ms->sq_slice(obj, cstart, cstop);
@@ -80153,13 +79483,15 @@ bad:
return NULL;
}
-#if !CYTHON_COMPILING_IN_CPYTHON
+/* StringJoin */
+ #if !CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) {
return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL);
}
#endif
-static CYTHON_INLINE int __Pyx_CheckKeywordStrings(
+/* KeywordStringCheck */
+ static CYTHON_INLINE int __Pyx_CheckKeywordStrings(
PyObject *kwdict,
const char* function_name,
int kw_allowed)
@@ -80198,7 +79530,8 @@ invalid_keyword:
return 0;
}
-static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
+/* UnpackUnboundCMethod */
+ static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
PyObject *method;
method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name);
if (unlikely(!method))
@@ -80217,7 +79550,8 @@ static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) {
return 0;
}
-static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
+/* CallUnboundCMethod0 */
+ static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) {
PyObject *args, *result = NULL;
if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL;
#if CYTHON_COMPILING_IN_CPYTHON
@@ -80235,14 +79569,16 @@ bad:
return result;
}
-static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) {
+/* py_dict_items */
+ static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) {
if (PY_MAJOR_VERSION >= 3)
return __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyDict_Type_items, d);
else
return PyDict_Items(d);
}
-static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
+/* GetAttr */
+ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
#if CYTHON_COMPILING_IN_CPYTHON
#if PY_MAJOR_VERSION >= 3
if (likely(PyUnicode_Check(n)))
@@ -80254,7 +79590,8 @@ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
return PyObject_GetAttr(o, n);
}
-static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
+/* GetAttr3 */
+ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) {
PyObject *r = __Pyx_GetAttr(o, n);
if (unlikely(!r)) {
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
@@ -80268,15 +79605,13 @@ bad:
return NULL;
}
-static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
+/* None */
+ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) {
PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname);
}
-#if CYTHON_USE_PYLONG_INTERNALS
- #include "longintrepr.h"
-#endif
-
-#if CYTHON_COMPILING_IN_CPYTHON
+/* PyIntBinop */
+ #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_CheckExact(op1))) {
@@ -80373,7 +79708,8 @@ static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED
}
#endif
-#if CYTHON_COMPILING_IN_CPYTHON
+/* PyIntBinop */
+ #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
if (op1 == op2) {
Py_RETURN_TRUE;
@@ -80457,7 +79793,8 @@ static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED
}
#endif
-static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
+/* SetItemInt */
+ static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
int r;
if (!j) return -1;
r = PyObject_SetItem(o, j, v);
@@ -80484,10 +79821,9 @@ static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObje
if (likely(l >= 0)) {
i += l;
} else {
- if (PyErr_ExceptionMatches(PyExc_OverflowError))
- PyErr_Clear();
- else
+ if (!PyErr_ExceptionMatches(PyExc_OverflowError))
return -1;
+ PyErr_Clear();
}
}
return m->sq_ass_item(o, i, v);
@@ -80505,7 +79841,8 @@ static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObje
return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
}
-static double __Pyx__PyObject_AsDouble(PyObject* obj) {
+/* pyobject_as_double */
+ static double __Pyx__PyObject_AsDouble(PyObject* obj) {
PyObject* float_value;
#if CYTHON_COMPILING_IN_PYPY
float_value = PyNumber_Float(obj); if (0) goto bad;
@@ -80544,7 +79881,8 @@ bad:
return (double)-1;
}
-static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value,
+/* SliceObject */
+ static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value,
Py_ssize_t cstart, Py_ssize_t cstop,
PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {
@@ -80579,10 +79917,9 @@ static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value,
if (cstart < 0) cstart = 0;
}
} else {
- if (PyErr_ExceptionMatches(PyExc_OverflowError))
- PyErr_Clear();
- else
+ if (!PyErr_ExceptionMatches(PyExc_OverflowError))
goto bad;
+ PyErr_Clear();
}
}
return ms->sq_ass_slice(obj, cstart, cstop, value);
@@ -80642,7 +79979,8 @@ bad:
return -1;
}
-static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
+/* ArgTypeTest */
+ static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) {
PyErr_Format(PyExc_TypeError,
"Argument '%.200s' has incorrect type (expected %.200s, got %.200s)",
name, type->tp_name, Py_TYPE(obj)->tp_name);
@@ -80668,7 +80006,8 @@ static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, in
return 0;
}
-#if CYTHON_COMPILING_IN_CPYTHON
+/* PyIntBinop */
+ #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) {
#if PY_MAJOR_VERSION < 3
if (likely(PyInt_CheckExact(op1))) {
@@ -80765,7 +80104,8 @@ static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_U
}
#endif
-static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
+/* PyObjectCallMethod1 */
+ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) {
PyObject *method, *result = NULL;
method = __Pyx_PyObject_GetAttrStr(obj, method_name);
if (unlikely(!method)) goto bad;
@@ -80796,7 +80136,8 @@ bad:
return result;
}
-static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
+/* append */
+ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
if (likely(PyList_CheckExact(L))) {
if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1;
} else {
@@ -80808,7 +80149,8 @@ static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
return 0;
}
-#if CYTHON_COMPILING_IN_CPYTHON
+/* PyFloatBinop */
+ #if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double floatval, CYTHON_UNUSED int inplace) {
const double b = floatval;
double a, result;
@@ -80875,14 +80217,16 @@ static PyObject* __Pyx_PyFloat_DivideObjC(PyObject *op1, PyObject *op2, double f
}
#endif
-static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d) {
+/* py_dict_keys */
+ static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d) {
if (PY_MAJOR_VERSION >= 3)
return __Pyx_CallUnboundCMethod0(&__pyx_umethod_PyDict_Type_keys, d);
else
return PyDict_Keys(d);
}
-static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
+/* Import */
+ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
PyObject *empty_list = 0;
PyObject *module = 0;
PyObject *global_dict = 0;
@@ -80955,7 +80299,8 @@ bad:
return module;
}
-static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
+/* ImportFrom */
+ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
PyErr_Format(PyExc_ImportError,
@@ -80968,7 +80313,8 @@ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
return value;
}
-static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
+/* CalculateMetaclass */
+ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases);
for (i=0; i < nbases; i++) {
PyTypeObject *tmptype;
@@ -81006,7 +80352,8 @@ static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bas
return (PyObject*) metaclass;
}
-static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
+/* FetchCommonType */
+ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
PyObject* fake_module;
PyTypeObject* cached_type = NULL;
fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
@@ -81044,7 +80391,8 @@ bad:
goto done;
}
-static PyObject *
+/* CythonFunction */
+ static PyObject *
__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
{
if (unlikely(op->func_doc == NULL)) {
@@ -81399,7 +80747,7 @@ __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
int i;
for (i = 0; i < m->defaults_pyobjects; i++)
Py_XDECREF(pydefaults[i]);
- PyMem_Free(m->defaults);
+ PyObject_Free(m->defaults);
m->defaults = NULL;
}
return 0;
@@ -81587,7 +80935,7 @@ static int __pyx_CyFunction_init(void) {
}
static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
__pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
- m->defaults = PyMem_Malloc(size);
+ m->defaults = PyObject_Malloc(size);
if (!m->defaults)
return PyErr_NoMemory();
memset(m->defaults, 0, size);
@@ -81610,7 +80958,8 @@ static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, Py
Py_INCREF(dict);
}
-static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
+/* Py3ClassCreate */
+ static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
PyObject *ns;
if (metaclass) {
@@ -81676,7 +81025,8 @@ static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObj
return result;
}
-static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
+/* CodeObjectCache */
+ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
int start = 0, mid = 0, end = count - 1;
if (end >= 0 && code_line > entries[end].code_line) {
return count;
@@ -81755,7 +81105,8 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
Py_INCREF(code_object);
}
-#include "compile.h"
+/* AddTraceback */
+ #include "compile.h"
#include "frameobject.h"
#include "traceback.h"
static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
@@ -81835,7 +81186,8 @@ bad:
Py_XDECREF(py_frame);
}
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
const long neg_one = (long) -1, const_zero = (long) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
@@ -81861,7 +81213,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
}
}
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
const int neg_one = (int) -1, const_zero = (int) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
@@ -81887,7 +81240,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) {
}
}
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value) {
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value) {
const unsigned long neg_one = (unsigned long) -1, const_zero = (unsigned long) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
@@ -81913,7 +81267,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long valu
}
}
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PY_LONG_LONG(PY_LONG_LONG value) {
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PY_LONG_LONG(PY_LONG_LONG value) {
const PY_LONG_LONG neg_one = (PY_LONG_LONG) -1, const_zero = (PY_LONG_LONG) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
@@ -81939,7 +81294,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_PY_LONG_LONG(PY_LONG_LONG value)
}
}
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value) {
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned PY_LONG_LONG value) {
const unsigned PY_LONG_LONG neg_one = (unsigned PY_LONG_LONG) -1, const_zero = (unsigned PY_LONG_LONG) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
@@ -81965,7 +81321,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned P
}
}
-#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
+/* CIntFromPyVerify */
+ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\
__PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\
__PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
@@ -81986,191 +81343,8 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_PY_LONG_LONG(unsigned P
return (target_type) value;\
}
-static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
- const int neg_one = (int) -1, const_zero = (int) 0;
- const int is_unsigned = neg_one > const_zero;
-#if PY_MAJOR_VERSION < 3
- if (likely(PyInt_Check(x))) {
- if (sizeof(int) < sizeof(long)) {
- __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
- } else {
- long val = PyInt_AS_LONG(x);
- if (is_unsigned && unlikely(val < 0)) {
- goto raise_neg_overflow;
- }
- return (int) val;
- }
- } else
-#endif
- if (likely(PyLong_Check(x))) {
- if (is_unsigned) {
-#if CYTHON_USE_PYLONG_INTERNALS
- const digit* digits = ((PyLongObject*)x)->ob_digit;
- switch (Py_SIZE(x)) {
- case 0: return (int) 0;
- case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
- case 2:
- if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
- return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
- }
- }
- break;
- case 3:
- if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
- return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
- }
- }
- break;
- case 4:
- if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
- return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
- }
- }
- break;
- }
-#endif
-#if CYTHON_COMPILING_IN_CPYTHON
- if (unlikely(Py_SIZE(x) < 0)) {
- goto raise_neg_overflow;
- }
-#else
- {
- int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
- if (unlikely(result < 0))
- return (int) -1;
- if (unlikely(result == 1))
- goto raise_neg_overflow;
- }
-#endif
- if (sizeof(int) <= sizeof(unsigned long)) {
- __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
- } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
- __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
- }
- } else {
-#if CYTHON_USE_PYLONG_INTERNALS
- const digit* digits = ((PyLongObject*)x)->ob_digit;
- switch (Py_SIZE(x)) {
- case 0: return (int) 0;
- case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0])
- case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0])
- case -2:
- if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
- return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
- }
- }
- break;
- case 2:
- if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
- return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
- }
- }
- break;
- case -3:
- if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
- return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
- }
- }
- break;
- case 3:
- if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
- return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
- }
- }
- break;
- case -4:
- if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
- return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
- }
- }
- break;
- case 4:
- if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
- if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
- __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
- } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
- return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
- }
- }
- break;
- }
-#endif
- if (sizeof(int) <= sizeof(long)) {
- __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
- } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
- __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
- }
- }
- {
-#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
- PyErr_SetString(PyExc_RuntimeError,
- "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
-#else
- int val;
- PyObject *v = __Pyx_PyNumber_Int(x);
- #if PY_MAJOR_VERSION < 3
- if (likely(v) && !PyLong_Check(v)) {
- PyObject *tmp = v;
- v = PyNumber_Long(tmp);
- Py_DECREF(tmp);
- }
- #endif
- if (likely(v)) {
- int one = 1; int is_little = (int)*(unsigned char *)&one;
- unsigned char *bytes = (unsigned char *)&val;
- int ret = _PyLong_AsByteArray((PyLongObject *)v,
- bytes, sizeof(val),
- is_little, !is_unsigned);
- Py_DECREF(v);
- if (likely(!ret))
- return val;
- }
-#endif
- return (int) -1;
- }
- } else {
- int val;
- PyObject *tmp = __Pyx_PyNumber_Int(x);
- if (!tmp) return (int) -1;
- val = __Pyx_PyInt_As_int(tmp);
- Py_DECREF(tmp);
- return val;
- }
-raise_overflow:
- PyErr_SetString(PyExc_OverflowError,
- "value too large to convert to int");
- return (int) -1;
-raise_neg_overflow:
- PyErr_SetString(PyExc_OverflowError,
- "can't convert negative value to int");
- return (int) -1;
-}
-
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_nc_type(nc_type value) {
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_nc_type(nc_type value) {
const nc_type neg_one = (nc_type) -1, const_zero = (nc_type) 0;
const int is_unsigned = neg_one > const_zero;
if (is_unsigned) {
@@ -82196,7 +81370,247 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_nc_type(nc_type value) {
}
}
-static CYTHON_INLINE nc_type __Pyx_PyInt_As_nc_type(PyObject *x) {
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_intp(npy_intp value) {
+ const npy_intp neg_one = (npy_intp) -1, const_zero = (npy_intp) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(npy_intp) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(npy_intp) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+ } else if (sizeof(npy_intp) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+ }
+ } else {
+ if (sizeof(npy_intp) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(npy_intp) <= sizeof(PY_LONG_LONG)) {
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
+ }
+ }
+ {
+ int one = 1; int little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&value;
+ return _PyLong_FromByteArray(bytes, sizeof(npy_intp),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntToPy */
+ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value) {
+ const char neg_one = (char) -1, const_zero = (char) 0;
+ const int is_unsigned = neg_one > const_zero;
+ if (is_unsigned) {
+ if (sizeof(char) < sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(char) <= sizeof(unsigned long)) {
+ return PyLong_FromUnsignedLong((unsigned long) value);
+ } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) {
+ return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+ }
+ } else {
+ if (sizeof(char) <= sizeof(long)) {
+ return PyInt_FromLong((long) value);
+ } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) {
+ return PyLong_FromLongLong((PY_LONG_LONG) value);
+ }
+ }
+ {
+ int one = 1; int little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&value;
+ return _PyLong_FromByteArray(bytes, sizeof(char),
+ little, !is_unsigned);
+ }
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) {
+ const int neg_one = (int) -1, const_zero = (int) 0;
+ const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+ if (likely(PyInt_Check(x))) {
+ if (sizeof(int) < sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x))
+ } else {
+ long val = PyInt_AS_LONG(x);
+ if (is_unsigned && unlikely(val < 0)) {
+ goto raise_neg_overflow;
+ }
+ return (int) val;
+ }
+ } else
+#endif
+ if (likely(PyLong_Check(x))) {
+ if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (int) 0;
+ case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0])
+ case 2:
+ if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) {
+ return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) {
+ return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) {
+ return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]));
+ }
+ }
+ break;
+ }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON
+ if (unlikely(Py_SIZE(x) < 0)) {
+ goto raise_neg_overflow;
+ }
+#else
+ {
+ int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+ if (unlikely(result < 0))
+ return (int) -1;
+ if (unlikely(result == 1))
+ goto raise_neg_overflow;
+ }
+#endif
+ if (sizeof(int) <= sizeof(unsigned long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x))
+ } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+ }
+ } else {
+#if CYTHON_USE_PYLONG_INTERNALS
+ const digit* digits = ((PyLongObject*)x)->ob_digit;
+ switch (Py_SIZE(x)) {
+ case 0: return (int) 0;
+ case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0]))
+ case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0])
+ case -2:
+ if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+ return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case 2:
+ if (8 * sizeof(int) > 1 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+ return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case -3:
+ if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+ return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case 3:
+ if (8 * sizeof(int) > 2 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+ return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case -4:
+ if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+ return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ case 4:
+ if (8 * sizeof(int) > 3 * PyLong_SHIFT) {
+ if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) {
+ __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])))
+ } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) {
+ return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])));
+ }
+ }
+ break;
+ }
+#endif
+ if (sizeof(int) <= sizeof(long)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x))
+ } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) {
+ __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x))
+ }
+ }
+ {
+#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray)
+ PyErr_SetString(PyExc_RuntimeError,
+ "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
+#else
+ int val;
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
+ #if PY_MAJOR_VERSION < 3
+ if (likely(v) && !PyLong_Check(v)) {
+ PyObject *tmp = v;
+ v = PyNumber_Long(tmp);
+ Py_DECREF(tmp);
+ }
+ #endif
+ if (likely(v)) {
+ int one = 1; int is_little = (int)*(unsigned char *)&one;
+ unsigned char *bytes = (unsigned char *)&val;
+ int ret = _PyLong_AsByteArray((PyLongObject *)v,
+ bytes, sizeof(val),
+ is_little, !is_unsigned);
+ Py_DECREF(v);
+ if (likely(!ret))
+ return val;
+ }
+#endif
+ return (int) -1;
+ }
+ } else {
+ int val;
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+ if (!tmp) return (int) -1;
+ val = __Pyx_PyInt_As_int(tmp);
+ Py_DECREF(tmp);
+ return val;
+ }
+raise_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "value too large to convert to int");
+ return (int) -1;
+raise_neg_overflow:
+ PyErr_SetString(PyExc_OverflowError,
+ "can't convert negative value to int");
+ return (int) -1;
+}
+
+/* CIntFromPy */
+ static CYTHON_INLINE nc_type __Pyx_PyInt_As_nc_type(PyObject *x) {
const nc_type neg_one = (nc_type) -1, const_zero = (nc_type) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
@@ -82271,7 +81685,7 @@ static CYTHON_INLINE nc_type __Pyx_PyInt_As_nc_type(PyObject *x) {
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (nc_type) 0;
- case -1: __PYX_VERIFY_RETURN_INT(nc_type, sdigit, -(sdigit) digits[0])
+ case -1: __PYX_VERIFY_RETURN_INT(nc_type, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(nc_type, digit, +digits[0])
case -2:
if (8 * sizeof(nc_type) - 1 > 1 * PyLong_SHIFT) {
@@ -82341,7 +81755,7 @@ static CYTHON_INLINE nc_type __Pyx_PyInt_As_nc_type(PyObject *x) {
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
nc_type val;
- PyObject *v = __Pyx_PyNumber_Int(x);
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
@@ -82364,7 +81778,7 @@ static CYTHON_INLINE nc_type __Pyx_PyInt_As_nc_type(PyObject *x) {
}
} else {
nc_type val;
- PyObject *tmp = __Pyx_PyNumber_Int(x);
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (nc_type) -1;
val = __Pyx_PyInt_As_nc_type(tmp);
Py_DECREF(tmp);
@@ -82380,7 +81794,8 @@ raise_neg_overflow:
return (nc_type) -1;
}
-static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
+/* CIntFromPy */
+ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
const size_t neg_one = (size_t) -1, const_zero = (size_t) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
@@ -82455,7 +81870,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (size_t) 0;
- case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, -(sdigit) digits[0])
+ case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +digits[0])
case -2:
if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) {
@@ -82525,7 +81940,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
size_t val;
- PyObject *v = __Pyx_PyNumber_Int(x);
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
@@ -82548,7 +81963,7 @@ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) {
}
} else {
size_t val;
- PyObject *tmp = __Pyx_PyNumber_Int(x);
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (size_t) -1;
val = __Pyx_PyInt_As_size_t(tmp);
Py_DECREF(tmp);
@@ -82564,7 +81979,8 @@ raise_neg_overflow:
return (size_t) -1;
}
-static CYTHON_INLINE ptrdiff_t __Pyx_PyInt_As_ptrdiff_t(PyObject *x) {
+/* CIntFromPy */
+ static CYTHON_INLINE ptrdiff_t __Pyx_PyInt_As_ptrdiff_t(PyObject *x) {
const ptrdiff_t neg_one = (ptrdiff_t) -1, const_zero = (ptrdiff_t) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
@@ -82639,7 +82055,7 @@ static CYTHON_INLINE ptrdiff_t __Pyx_PyInt_As_ptrdiff_t(PyObject *x) {
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (ptrdiff_t) 0;
- case -1: __PYX_VERIFY_RETURN_INT(ptrdiff_t, sdigit, -(sdigit) digits[0])
+ case -1: __PYX_VERIFY_RETURN_INT(ptrdiff_t, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(ptrdiff_t, digit, +digits[0])
case -2:
if (8 * sizeof(ptrdiff_t) - 1 > 1 * PyLong_SHIFT) {
@@ -82709,7 +82125,7 @@ static CYTHON_INLINE ptrdiff_t __Pyx_PyInt_As_ptrdiff_t(PyObject *x) {
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
ptrdiff_t val;
- PyObject *v = __Pyx_PyNumber_Int(x);
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
@@ -82732,7 +82148,7 @@ static CYTHON_INLINE ptrdiff_t __Pyx_PyInt_As_ptrdiff_t(PyObject *x) {
}
} else {
ptrdiff_t val;
- PyObject *tmp = __Pyx_PyNumber_Int(x);
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (ptrdiff_t) -1;
val = __Pyx_PyInt_As_ptrdiff_t(tmp);
Py_DECREF(tmp);
@@ -82748,33 +82164,8 @@ raise_neg_overflow:
return (ptrdiff_t) -1;
}
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_npy_intp(npy_intp value) {
- const npy_intp neg_one = (npy_intp) -1, const_zero = (npy_intp) 0;
- const int is_unsigned = neg_one > const_zero;
- if (is_unsigned) {
- if (sizeof(npy_intp) < sizeof(long)) {
- return PyInt_FromLong((long) value);
- } else if (sizeof(npy_intp) <= sizeof(unsigned long)) {
- return PyLong_FromUnsignedLong((unsigned long) value);
- } else if (sizeof(npy_intp) <= sizeof(unsigned PY_LONG_LONG)) {
- return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
- }
- } else {
- if (sizeof(npy_intp) <= sizeof(long)) {
- return PyInt_FromLong((long) value);
- } else if (sizeof(npy_intp) <= sizeof(PY_LONG_LONG)) {
- return PyLong_FromLongLong((PY_LONG_LONG) value);
- }
- }
- {
- int one = 1; int little = (int)*(unsigned char *)&one;
- unsigned char *bytes = (unsigned char *)&value;
- return _PyLong_FromByteArray(bytes, sizeof(npy_intp),
- little, !is_unsigned);
- }
-}
-
-static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
+/* CIntFromPy */
+ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
const long neg_one = (long) -1, const_zero = (long) 0;
const int is_unsigned = neg_one > const_zero;
#if PY_MAJOR_VERSION < 3
@@ -82849,7 +82240,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
const digit* digits = ((PyLongObject*)x)->ob_digit;
switch (Py_SIZE(x)) {
case 0: return (long) 0;
- case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0])
+ case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0]))
case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0])
case -2:
if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) {
@@ -82919,7 +82310,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
"_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers");
#else
long val;
- PyObject *v = __Pyx_PyNumber_Int(x);
+ PyObject *v = __Pyx_PyNumber_IntOrLong(x);
#if PY_MAJOR_VERSION < 3
if (likely(v) && !PyLong_Check(v)) {
PyObject *tmp = v;
@@ -82942,7 +82333,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) {
}
} else {
long val;
- PyObject *tmp = __Pyx_PyNumber_Int(x);
+ PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
if (!tmp) return (long) -1;
val = __Pyx_PyInt_As_long(tmp);
Py_DECREF(tmp);
@@ -82958,52 +82349,33 @@ raise_neg_overflow:
return (long) -1;
}
-static CYTHON_INLINE PyObject* __Pyx_PyInt_From_char(char value) {
- const char neg_one = (char) -1, const_zero = (char) 0;
- const int is_unsigned = neg_one > const_zero;
- if (is_unsigned) {
- if (sizeof(char) < sizeof(long)) {
- return PyInt_FromLong((long) value);
- } else if (sizeof(char) <= sizeof(unsigned long)) {
- return PyLong_FromUnsignedLong((unsigned long) value);
- } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) {
- return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
- }
- } else {
- if (sizeof(char) <= sizeof(long)) {
- return PyInt_FromLong((long) value);
- } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) {
- return PyLong_FromLongLong((PY_LONG_LONG) value);
- }
- }
- {
- int one = 1; int little = (int)*(unsigned char *)&one;
- unsigned char *bytes = (unsigned char *)&value;
- return _PyLong_FromByteArray(bytes, sizeof(char),
- little, !is_unsigned);
- }
-}
-
-static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
+/* SwapException */
+ #if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
PyObject *tmp_type, *tmp_value, *tmp_tb;
-#if CYTHON_COMPILING_IN_CPYTHON
- PyThreadState *tstate = PyThreadState_GET();
tmp_type = tstate->exc_type;
tmp_value = tstate->exc_value;
tmp_tb = tstate->exc_traceback;
tstate->exc_type = *type;
tstate->exc_value = *value;
tstate->exc_traceback = *tb;
+ *type = tmp_type;
+ *value = tmp_value;
+ *tb = tmp_tb;
+}
#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
+ PyObject *tmp_type, *tmp_value, *tmp_tb;
PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
PyErr_SetExcInfo(*type, *value, *tb);
-#endif
*type = tmp_type;
*value = tmp_value;
*tb = tmp_tb;
}
+#endif
-#include <structmember.h>
+/* CoroutineBase */
+ #include <structmember.h>
#include <frameobject.h>
static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value);
static PyObject *__Pyx_Coroutine_Close(PyObject *self);
@@ -83013,6 +82385,8 @@ static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args);
static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue) {
PyObject *et, *ev, *tb;
PyObject *value = NULL;
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
__Pyx_ErrFetch(&et, &ev, &tb);
if (!et) {
Py_XDECREF(tb);
@@ -83117,6 +82491,7 @@ int __Pyx_Coroutine_CheckRunning(__pyx_CoroutineObject *gen) {
static CYTHON_INLINE
PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value) {
PyObject *retval;
+ __Pyx_PyThreadState_declare
assert(!self->is_running);
if (unlikely(self->resume_label == 0)) {
if (unlikely(value && value != Py_None)) {
@@ -83130,16 +82505,16 @@ PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value) {
PyErr_SetNone(PyExc_StopIteration);
return NULL;
}
+ __Pyx_PyThreadState_assign
if (value) {
#if CYTHON_COMPILING_IN_PYPY
#else
if (self->exc_traceback) {
- PyThreadState *tstate = PyThreadState_GET();
PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback;
PyFrameObject *f = tb->tb_frame;
- Py_XINCREF(tstate->frame);
+ Py_XINCREF(__pyx_tstate->frame);
assert(f->f_back == NULL);
- f->f_back = tstate->frame;
+ f->f_back = __pyx_tstate->frame;
}
#endif
__Pyx_ExceptionSwap(&self->exc_type, &self->exc_value,
@@ -83204,7 +82579,7 @@ static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) {
#endif
{
if (value == Py_None)
- ret = PyIter_Next(yf);
+ ret = Py_TYPE(yf)->tp_iternext(yf);
else
ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value);
}
@@ -83413,12 +82788,14 @@ static void __Pyx_Coroutine_del(PyObject *self) {
PyObject *res;
PyObject *error_type, *error_value, *error_traceback;
__pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self;
+ __Pyx_PyThreadState_declare
if (gen->resume_label <= 0)
return ;
#if PY_VERSION_HEX < 0x030400a1
assert(self->ob_refcnt == 0);
self->ob_refcnt = 1;
#endif
+ __Pyx_PyThreadState_assign
__Pyx_ErrFetch(&error_type, &error_value, &error_traceback);
res = __Pyx_Coroutine_Close(self);
if (res == NULL)
@@ -83521,7 +82898,8 @@ static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject* type, __pyx_cor
return gen;
}
-static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) {
+/* PatchModuleWithCoroutine */
+ static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) {
#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
int result;
PyObject *globals, *result_obj;
@@ -83560,7 +82938,8 @@ ignore:
return module;
}
-#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
+/* PatchGeneratorABC */
+ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
static PyObject* __Pyx_patch_abc_module(PyObject *module);
static PyObject* __Pyx_patch_abc_module(PyObject *module) {
module = __Pyx_Coroutine_patch_module(
@@ -83613,7 +82992,8 @@ static int __Pyx_patch_abc(void) {
return 0;
}
-static PyMethodDef __pyx_Generator_methods[] = {
+/* Generator */
+ static PyMethodDef __pyx_Generator_methods[] = {
{"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O,
(char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")},
{"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS,
@@ -83701,7 +83081,8 @@ static int __pyx_Generator_init(void) {
return 0;
}
-static int __Pyx_check_binary_version(void) {
+/* CheckBinaryVersion */
+ static int __Pyx_check_binary_version(void) {
char ctversion[4], rtversion[4];
PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
@@ -83716,7 +83097,8 @@ static int __Pyx_check_binary_version(void) {
return 0;
}
-#ifndef __PYX_HAVE_RT_ImportModule
+/* ModuleImport */
+ #ifndef __PYX_HAVE_RT_ImportModule
#define __PYX_HAVE_RT_ImportModule
static PyObject *__Pyx_ImportModule(const char *name) {
PyObject *py_name = 0;
@@ -83733,7 +83115,8 @@ bad:
}
#endif
-#ifndef __PYX_HAVE_RT_ImportType
+/* TypeImport */
+ #ifndef __PYX_HAVE_RT_ImportType
#define __PYX_HAVE_RT_ImportType
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
size_t size, int strict)
@@ -83779,14 +83162,14 @@ static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class
#endif
if (!strict && (size_t)basicsize > size) {
PyOS_snprintf(warning, sizeof(warning),
- "%s.%s size changed, may indicate binary incompatibility",
- module_name, class_name);
+ "%s.%s size changed, may indicate binary incompatibility. Expected %zd, got %zd",
+ module_name, class_name, basicsize, size);
if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
}
else if ((size_t)basicsize != size) {
PyErr_Format(PyExc_ValueError,
- "%.200s.%.200s has the wrong size, try recompiling",
- module_name, class_name);
+ "%.200s.%.200s has the wrong size, try recompiling. Expected %zd, got %zd",
+ module_name, class_name, basicsize, size);
goto bad;
}
return (PyTypeObject *)result;
@@ -83797,7 +83180,8 @@ bad:
}
#endif
-static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
+/* InitStrings */
+ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
while (t->p) {
#if PY_MAJOR_VERSION < 3
if (t->is_unicode) {
@@ -83897,7 +83281,7 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
else return PyObject_IsTrue(x);
}
-static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) {
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
PyNumberMethods *m;
const char *name = NULL;
PyObject *res = NULL;
diff --git a/netCDF4/_netCDF4.pyx b/netCDF4/_netCDF4.pyx
index 2a24c06..ad6edd6 100644
--- a/netCDF4/_netCDF4.pyx
+++ b/netCDF4/_netCDF4.pyx
@@ -1,5 +1,5 @@
"""
-Version 1.2.3
+Version 1.2.4
-------------
- - -
@@ -45,8 +45,11 @@ Requires
will be disabled to preserve backward compatibility with older versions of the netCDF
library.
- For python < 2.7, the [ordereddict module](http://python.org/pypi/ordereddict).
- - The HDF5 C library version 1.8.4-patch1 or higher (1.8.8 or higher
- recommended) from [](ftp://ftp.hdfgroup.org/HDF5/current/src).
+ - The HDF5 C library version 1.8.4-patch1 or higher (1.8.x recommended)
+ from [](ftp://ftp.hdfgroup.org/HDF5/current/src).
+ ***netCDF version 4.4.1 or higher is recommended if using HDF5 1.10.x -
+ otherwise resulting files may be unreadable by clients using earlier
+ versions of HDF5. For netCDF < 4.4.1, HDF5 version 1.8.x is recommended.***
Be sure to build with `--enable-hl --enable-shared`.
- [Libcurl](http://curl.haxx.se/libcurl), if you want
[OPeNDAP](http://opendap.org) support.
@@ -277,7 +280,7 @@ can be used to determine if the dimensions is unlimited, or appendable.
:::python
>>> print len(lon)
144
- >>> print len.isunlimited()
+ >>> print lon.isunlimited()
False
>>> print time.isunlimited()
True
@@ -539,7 +542,7 @@ metadata standards (such as CF) specify that time should be
measure relative to a fixed date using a certain calendar, with units
specified like `hours since YY:MM:DD hh-mm-ss`. These units can be
awkward to deal with, without a utility to convert the values to and
-from calendar dates. The functione called `netCDF4.num2date` and `netCDF4.date2num` are
+from calendar dates. The function called `netCDF4.num2date` and `netCDF4.date2num` are
provided with this package to do just that. Here's an example of how they
can be used:
@@ -932,7 +935,7 @@ except ImportError:
# python3: zip is already python2's itertools.izip
pass
-__version__ = "1.2.3"
+__version__ = "1.2.4"
# Initialize numpy
import posixpath
@@ -980,6 +983,16 @@ _needsworkaround_issue485 = __netcdf4libversion__ < "4.4.0" or \
(__netcdf4libversion__.startswith("4.4.0") and \
"-development" in __netcdf4libversion__)
+# issue warning for hdf5 1.10 (issue #549)
+if __netcdf4libversion__[0:5] < "4.4.1" and\
+ __hdf5libversion__.startswith("1.10"):
+ msg = """
+WARNING: Backwards incompatible files will be created with HDF5 1.10.x
+and netCDF < 4.4.1. Upgrading to netCDF4 >= 4.4.1 or downgrading to
+to HDF5 version 1.8.x is highly recommended
+(see https://github.com/Unidata/netcdf-c/issues/250)."""
+ warnings.warn(msg)
+
# numpy data type <--> netCDF 4 data type mapping.
_nptonctype = {'S1' : NC_CHAR,
'i1' : NC_BYTE,
@@ -1072,13 +1085,13 @@ cdef _get_att_names(int grpid, int varid):
with nogil:
ierr = nc_inq_varnatts(grpid, varid, &numatts)
if ierr != NC_NOERR:
- raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
attslist = []
for n from 0 <= n < numatts:
with nogil:
ierr = nc_inq_attname(grpid, varid, n, namstring)
if ierr != NC_NOERR:
- raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
attslist.append(namstring.decode(default_encoding,unicode_error))
return attslist
@@ -1444,16 +1457,13 @@ cdef _get_vars(group):
raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
# get endian-ness of variable.
endianness = None
- # assume data returned by HDF4 lib has already been byte-swapped
- # (if needed) so that it is in native endian format (issue #391).
- if group.disk_format != 'HDF4':
- with nogil:
- ierr = nc_inq_var_endian(_grpid, varid, &iendian)
- if ierr == NC_NOERR:
- if iendian == NC_ENDIAN_LITTLE:
- endianness = '<'
- elif iendian == NC_ENDIAN_BIG:
- endianness = '>'
+ with nogil:
+ ierr = nc_inq_var_endian(_grpid, varid, &iendian)
+ if ierr == NC_NOERR:
+ if iendian == NC_ENDIAN_LITTLE:
+ endianness = '<'
+ elif iendian == NC_ENDIAN_BIG:
+ endianness = '>'
# check to see if it is a supported user-defined type.
try:
datatype = _nctonptype[xtype]
@@ -1798,7 +1808,7 @@ references to the parent Dataset or Group.
else:
raise ValueError("mode must be 'w', 'r', 'a' or 'r+', got '%s'" % mode)
if ierr != NC_NOERR:
- raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ raise IOError((<char *>nc_strerror(ierr)).decode('ascii'))
# data model and file format attributes
self.data_model = _get_format(grpid)
# data_model attribute used to be file_format (versions < 1.0.8), retain
@@ -2089,7 +2099,7 @@ 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'),('x','y'),float)` will create groups `GroupA`
+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.
@@ -2345,7 +2355,7 @@ attributes."""
ierr = nc_del_att(self._grpid, NC_GLOBAL, attname)
if self.data_model != 'NETCDF4': self._enddef()
if ierr != NC_NOERR:
- raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
def __setattr__(self,name,value):
# if name in _private_atts, it is stored at the python
@@ -3593,7 +3603,7 @@ details."""
# level and not in the netCDF file.
if name not in _private_atts:
# if setting _FillValue or missing_value, make sure value
- # has same type as variable.
+ # has same type and byte order as variable.
if name == '_FillValue':
msg='_FillValue attribute must be set when variable is '+\
'created (using fill_value keyword to createVariable)'
@@ -3605,7 +3615,11 @@ details."""
# "VLEN or compound variable"
# raise AttributeError(msg)
elif name == 'missing_value' and self._isprimitive:
- value = numpy.array(value, self.dtype)
+ if (is_native_little and self.endian() == 'big') or\
+ (is_native_big and self.endian() == 'little'):
+ value = numpy.array(value, self.dtype).byteswap(True)
+ else:
+ value = numpy.array(value, self.dtype)
self.setncattr(name, value)
elif not name.endswith('__'):
if hasattr(self,name):
@@ -3646,7 +3660,7 @@ rename a `netCDF4.Variable` attribute named `oldname` to `newname`."""
newnamec = bytestr
ierr = nc_rename_att(self._grpid, self._varid, oldnamec, newnamec)
if ierr != NC_NOERR:
- raise RuntimeError((<char *>nc_strerror(ierr)).decode('ascii'))
+ raise AttributeError((<char *>nc_strerror(ierr)).decode('ascii'))
def __getitem__(self, elem):
# This special method is used to index the netCDF variable
@@ -3736,10 +3750,9 @@ rename a `netCDF4.Variable` attribute named `oldname` to `newname`."""
totalmask = numpy.zeros(data.shape, numpy.bool)
fill_value = None
if hasattr(self, 'missing_value'):
+ # note: missing_value has to have same endian-ness as variable
+ # or this won't work.
mval = numpy.array(self.missing_value, self.dtype)
- if (self.endian() == 'big' and is_native_little) or\
- (self.endian() == 'little' and is_native_big):
- mval.byteswap(True)
if mval.shape == (): # mval a scalar.
hasmval = data==mval
# is scalar missing value a NaN?
@@ -3763,11 +3776,6 @@ rename a `netCDF4.Variable` attribute named `oldname` to `newname`."""
totalmask += mask
if hasattr(self, '_FillValue'):
fval = numpy.array(self._FillValue, self.dtype)
- # byte swap the _FillValue if endian-ness of the variable
- # is not native.
- if (self.endian() == 'big' and is_native_little) or\
- (self.endian() == 'little' and is_native_big):
- fval.byteswap(True)
# is _FillValue a NaN?
try:
fvalisnan = numpy.isnan(fval)
@@ -3804,11 +3812,6 @@ rename a `netCDF4.Variable` attribute named `oldname` to `newname`."""
# value unless a _FillValue attribute is set explicitly."
if no_fill != 1 and self.dtype.str[1:] not in ['u1','i1']:
fillval = numpy.array(default_fillvals[self.dtype.str[1:]],self.dtype)
- # byte swap the _FillValue if endian-ness of the variable
- # is not native.
- if (self.endian() == 'big' and is_native_little) or\
- (self.endian() == 'little' and is_native_big):
- fillval.byteswap(True)
has_fillval = data == fillval
# if data is an array scalar, has_fillval will be a boolean.
# in that case convert to an array.
@@ -4238,23 +4241,12 @@ The default value of `mask` is `True`
# try to cast the data.
if self.dtype != data.dtype:
data = data.astype(self.dtype) # cast data, if necessary.
- # make sure byte-order of data matches byte-order of netcdf
- # variable.
- if self.endian() == 'native':
- if is_native_little and data.dtype.byteorder == '>':
- data.byteswap(True)
- if is_native_big and data.dtype.byteorder == '<':
- data.byteswap(True)
- if self.endian() == 'big':
- if is_native_big and data.dtype.byteorder not in ['=','|']:
- data.byteswap(True)
- if is_native_little and data.dtype.byteorder == '=':
- data.byteswap(True)
- if self.endian() == 'little':
- if is_native_little and data.dtype.byteorder not in ['=','|']:
- data.byteswap(True)
- if is_native_big and data.dtype.byteorder == '=':
- data.byteswap(True)
+ # byte-swap data in numpy array so that is has native
+ # endian byte order (this is what netcdf-c expects -
+ # issue #554, pull request #555)
+ if (is_native_little and data.dtype.byteorder == '>') or\
+ (is_native_big and data.dtype.byteorder == '<'):
+ data = data.byteswap() # don't do in-place, make a copy
# strides all 1 or scalar variable, use put_vara (faster)
if sum(stride) == ndims or ndims == 0:
ierr = nc_put_vara(self._grpid, self._varid,
@@ -4453,6 +4445,14 @@ The default value of `mask` is `True`
if negstride:
# reverse data along axes with negative strides.
data = data[sl].copy() # make a copy so data is contiguous.
+ # netcdf-c always returns data in native byte order,
+ # regardless of variable endian-ness. Here we swap the
+ # bytes if the variable dtype is not native endian, so the
+ # dtype of the returned numpy array matches the variable dtype.
+ # (pull request #555, issue #554).
+ if (self.endian() == 'big' and is_native_little) or\
+ (self.endian() == 'little' and is_native_big):
+ data.byteswap(True) # in-place byteswap
if not self.dimensions:
return data[0] # a scalar
elif squeeze_out:
diff --git a/setup.py b/setup.py
index b22d10b..10db390 100644
--- a/setup.py
+++ b/setup.py
@@ -449,7 +449,7 @@ else:
setup(name = "netCDF4",
cmdclass = cmdclass,
- version = "1.2.3.1",
+ version = "1.2.4",
long_description = "netCDF version 4 has many features not found in earlier versions of the library, such as hierarchical groups, zlib compression, multiple unlimited dimensions, and new data types. It is implemented on top of HDF5. This module implements most of the new features, and can read and write netCDF files compatible with older versions of the library. The API is modelled after Scientific.IO.NetCDF, and should be familiar to users of that module.\n\nThis project has a `Sub [...]
author = "Jeff Whitaker",
author_email = "jeffrey.s.whitaker at noaa.gov",
diff --git a/test/tst_atts.py b/test/tst_atts.py
index e7dfe7b..c972a90 100644
--- a/test/tst_atts.py
+++ b/test/tst_atts.py
@@ -4,6 +4,8 @@ import sys
import unittest
import os
import tempfile
+import warnings
+
import numpy as NP
from numpy.random.mtrand import uniform
import netCDF4
@@ -14,7 +16,7 @@ except ImportError: # or else use drop-in substitute
from ordereddict import OrderedDict
# test attribute creation.
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
VAR_NAME="dummy_var"
GROUP_NAME = "dummy_group"
DIM1_NAME="x"
@@ -139,17 +141,25 @@ class VariablesTestCase(unittest.TestCase):
assert v.getncattr('foo') == 1
assert v.getncattr('bar') == 2
# check type of attributes using ncdump (issue #529)
- dep=subprocess.Popen(['ncdump','-h',FILE_NAME],stdout=subprocess.PIPE).communicate()[0]
- try: # python 2
- ncdump_output = dep.split('\n')
- except TypeError: # python 3
- ncdump_output = str(dep,encoding='utf-8').split('\n')
- for line in ncdump_output:
- line = line.strip('\t\n\r')
- if "stringatt" in line: assert line.startswith('string')
- if "charatt" in line: assert line.startswith(':')
- if "cafe" in line: assert line.startswith('string')
- if "batt" in line: assert line.startswith(':')
+ try: # ncdump may not be on the system PATH
+ nc_proc = subprocess.Popen(
+ ['ncdump', '-h', FILE_NAME], stdout=subprocess.PIPE)
+ except OSError:
+ warnings.warn('"ncdump" not on system path; cannot test '
+ 'read of some attributes')
+ pass
+ else: # We do have ncdump output
+ dep = nc_proc.communicate()[0]
+ try: # python 2
+ ncdump_output = dep.split('\n')
+ except TypeError: # python 3
+ ncdump_output = str(dep,encoding='utf-8').split('\n')
+ for line in ncdump_output:
+ line = line.strip('\t\n\r')
+ if "stringatt" in line: assert line.startswith('string')
+ if "charatt" in line: assert line.startswith(':')
+ if "cafe" in line: assert line.startswith('string')
+ if "batt" in line: assert line.startswith(':')
# check attributes in subgroup.
# global attributes.
for key,val in ATTDICT.items():
diff --git a/test/tst_cdf5.py b/test/tst_cdf5.py
index 1e8749e..1b46c91 100644
--- a/test/tst_cdf5.py
+++ b/test/tst_cdf5.py
@@ -3,7 +3,7 @@ import numpy as np
import sys, os, unittest, tempfile
from numpy.testing import assert_array_equal
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
dimsize = np.iinfo(np.int64).max # max unsigned 64 bit integer
ndim = 100
arrdata = np.random.randint(np.iinfo(np.uint8).min,np.iinfo(np.uint8).max,size=ndim)
diff --git a/test/tst_compound_alignment.py b/test/tst_compound_alignment.py
index 5990053..23e670e 100644
--- a/test/tst_compound_alignment.py
+++ b/test/tst_compound_alignment.py
@@ -75,7 +75,7 @@ cells = numpy.array([ (387, 289, 65.64321899414062, -167.90093994140625, 355
(396, 290, 65.71821594238281, -167.9770050048828, 3545, -10149, 8941, -16614, 9, 34164, 1, 0, 200, 526, 511, 301, 170, 65528, 35, 1480, 2350, 3029, 2645, 2928, 5907, 11842, 6208, 16528, 7384, 7988, 870, 527, 661, 3054, 2504, 3291, 3235, 2490, 3424, 354, 354, 10039, 10988, 7958, 7395, 7902, 8811, 14853, 16836, 17231, 20852, 13, 7, 6, 15, 15, 15, 15, 0, 10, 5, 8, 8, 4, 5, 4, 7, 0, 0, 12, 13, 15, 5, 12, 2, 2, 6, 3, 15, 15, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 28, 6, 6, 6, 0, 6, 0, 0, 2 [...]
dtype=[('mxd03_granule_row', '<i2'), ('mxd03_granule_column', '<i2'), ('mxd03_latitude', '<f4'), ('mxd03_longitude', '<f4'), ('mxd03_sensor_zenith', '<i2'), ('mxd03_sensor_azimuth', '<i2'), ('mxd03_solar_zenith', '<i2'), ('mxd03_solar_azimuth', '<i2'), ('mxd03_height', '<i2'), ('mxd03_range', '<u2'), ('mxd03_land_sea_mask', '|u1'), ('mxd03_gflags', '|u1'), ('mxd02_band_1A', '<u2'), ('mxd02_band_2A', '<u2'), ('mxd02_band_3A', '<u2'), ('mxd02_band_4A', '<u2'), ('mxd02_band_5A', '<u2' [...]
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
class CompoundAlignTestCase(unittest.TestCase):
diff --git a/test/tst_compoundatt.py b/test/tst_compoundatt.py
index 939039d..4ce2516 100644
--- a/test/tst_compoundatt.py
+++ b/test/tst_compoundatt.py
@@ -9,7 +9,7 @@ from numpy.testing import assert_array_equal, assert_array_almost_equal
# test compound attributes.
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
DIM_NAME = 'time'
VAR_NAME = 'wind'
VAR_NAME2 = 'forecast_wind'
diff --git a/test/tst_compoundvar.py b/test/tst_compoundvar.py
index 90176d2..ef9ea0e 100644
--- a/test/tst_compoundvar.py
+++ b/test/tst_compoundvar.py
@@ -9,7 +9,7 @@ from numpy.testing import assert_array_equal, assert_array_almost_equal
# test compound data types.
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
#FILE_NAME = 'test.nc'
DIM_NAME = 'phony_dim'
GROUP_NAME = 'phony_group'
diff --git a/test/tst_compression.py b/test/tst_compression.py
index 642a97c..a0a5e99 100644
--- a/test/tst_compression.py
+++ b/test/tst_compression.py
@@ -8,7 +8,7 @@ ndim = 100000
ndim2 = 100
chunk1 = 10; chunk2 = ndim2
nfiles = 7
-files = [tempfile.mktemp(".nc") for nfile in range(nfiles)]
+files = [tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name for nfile in range(nfiles)]
array = uniform(size=(ndim,))
array2 = uniform(size=(ndim,ndim2))
lsd = 3
diff --git a/test/tst_dims.py b/test/tst_dims.py
index fc02d40..cb91b7d 100644
--- a/test/tst_dims.py
+++ b/test/tst_dims.py
@@ -6,7 +6,7 @@ import numpy as NP
from numpy.random.mtrand import uniform
import netCDF4
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
LAT_NAME="lat"
LAT_LEN = 25
LAT_LENG = 50
diff --git a/test/tst_diskless.py b/test/tst_diskless.py
index b7a55b8..a96a0c8 100644
--- a/test/tst_diskless.py
+++ b/test/tst_diskless.py
@@ -12,8 +12,8 @@ n2dim = 73
n3dim = 144
ranarr = 100.*uniform(size=(n1dim,n2dim,n3dim))
ranarr2 = 100.*uniform(size=(n1dim,n2dim,n3dim))
-FILE_NAME = tempfile.mktemp(".nc")
-FILE_NAME2 = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=True).name
+FILE_NAME2 = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
class DisklessTestCase(unittest.TestCase):
diff --git a/test/tst_endian.py b/test/tst_endian.py
index 693c48e..6856704 100644
--- a/test/tst_endian.py
+++ b/test/tst_endian.py
@@ -4,8 +4,9 @@ import unittest, os, tempfile
from numpy.testing import assert_array_equal, assert_array_almost_equal
data = np.arange(12,dtype='f4').reshape(3,4)
-FILE_NAME = tempfile.mktemp(".nc")
-FILE_NAME2 = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
+FILE_NAME2 = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
+FILE_NAME3 = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
def create_file(file,format,data):
import warnings
@@ -26,6 +27,29 @@ def create_file(file,format,data):
bb[:] = big
dataset.close()
+def check_byteswap(file, data):
+ # byteswapping is done internally to native endian format
+ # when numpy array has non-native byte order. The byteswap was
+ # initially done in place, which caused the numpy array to
+ # be modified in the calling program. Pull request #555
+ # changed the byteswap to a copy, and this test checks
+ # to make sure the input numpy array is not modified.
+ dataset = netCDF4.Dataset(file,'w')
+ dataset.createDimension('time', None)
+ dataset.createDimension('space', 4)
+ dims = ('time', 'space')
+ bl = dataset.createVariable('big-little', np.float32, dims, endian='big')
+ data2 = data.copy()
+ bl[:] = data
+ dataset.close()
+ f = netCDF4.Dataset(file)
+ bl = f.variables['big-little'][:]
+ # check data.
+ assert_array_almost_equal(data, data2)
+ assert_array_almost_equal(bl, data)
+ f.close()
+
+
def check_data(file, data):
f = netCDF4.Dataset(file)
ll = f.variables['little-little'][:]
@@ -52,9 +76,19 @@ def issue310(file):
var_big_endian = nc.createVariable(\
'obs_big_endian', '>f8', ('obs', ),\
endian=endian,fill_value=fval)
+ # use default _FillValue
+ var_big_endian2 = nc.createVariable(\
+ 'obs_big_endian2', '>f8', ('obs', ),\
+ endian=endian)
+ # NOTE: missing_value be written in same byte order
+ # as variable, or masked array won't be masked correctly
+ # when data is read in.
var_big_endian.missing_value = mval
var_big_endian[0]=np.pi
var_big_endian[1]=mval
+ var_big_endian2.missing_value = mval
+ var_big_endian2[0]=np.pi
+ var_big_endian2[1]=mval
var_native_endian = nc.createVariable(\
'obs_native_endian', '<f8', ('obs', ),\
endian='native',fill_value=fval)
@@ -63,6 +97,8 @@ def issue310(file):
var_native_endian[1]=mval
assert_array_almost_equal(var_native_endian[:].filled(),
var_big_endian[:].filled())
+ assert_array_almost_equal(var_big_endian[:].filled(),
+ var_big_endian2[:].filled())
nc.close()
def issue346(file):
@@ -90,16 +126,19 @@ class EndianTestCase(unittest.TestCase):
def setUp(self):
create_file(FILE_NAME,'NETCDF4_CLASSIC',data); self.file=FILE_NAME
create_file(FILE_NAME2,'NETCDF3_CLASSIC',data); self.file2=FILE_NAME2
+ self.file3 = FILE_NAME3
def tearDown(self):
# Remove the temporary files
os.remove(self.file)
os.remove(self.file2)
+ os.remove(self.file3)
def runTest(self):
"""testing endian conversion capability"""
check_data(self.file, data)
check_data(self.file2, data)
+ check_byteswap(self.file3, data)
issue310(self.file)
issue346(self.file2)
diff --git a/test/tst_enum.py b/test/tst_enum.py
index d8f737b..188e722 100644
--- a/test/tst_enum.py
+++ b/test/tst_enum.py
@@ -6,7 +6,7 @@ from netCDF4 import Dataset
import numpy as np
from numpy.testing import assert_array_equal
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
ENUM_NAME = 'cloud_t'
ENUM_BASETYPE = np.int8
VAR_NAME = 'primary_cloud'
diff --git a/test/tst_fancyslicing.py b/test/tst_fancyslicing.py
index 32b9b2a..7421695 100644
--- a/test/tst_fancyslicing.py
+++ b/test/tst_fancyslicing.py
@@ -19,7 +19,7 @@ to be checked.)
See test2unlim below for an example.
"""
-file_name = tempfile.mktemp(".nc")
+file_name = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
xdim=9; ydim=10; zdim=11
i = np.array([2,5,7],'i4')
i2 = np.array([0,8],'i4')
diff --git a/test/tst_grps.py b/test/tst_grps.py
index dd66674..2794d1c 100644
--- a/test/tst_grps.py
+++ b/test/tst_grps.py
@@ -7,8 +7,8 @@ import netCDF4
# test group creation.
-FILE_NAME1 = tempfile.mktemp(".nc")
-FILE_NAME2 = tempfile.mktemp(".nc")
+FILE_NAME1 = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
+FILE_NAME2 = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
DYNASTY=u"Tudor"
HENRY_VII=u"Henry_VII"
MARGARET=u"Margaret"
diff --git a/test/tst_grps2.py b/test/tst_grps2.py
index 13c471c..ad98a2f 100644
--- a/test/tst_grps2.py
+++ b/test/tst_grps2.py
@@ -9,7 +9,7 @@ import netCDF4
# in createVariable and createGroups (added in 1.1.8).
# also test Dataset.__getitem__, also added in 1.1.8.
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
class Groups2TestCase(unittest.TestCase):
diff --git a/test/tst_masked.py b/test/tst_masked.py
index ba0554e..cda9a21 100644
--- a/test/tst_masked.py
+++ b/test/tst_masked.py
@@ -12,7 +12,7 @@ import netCDF4
# packing/unpacking of short ints.
# create an n1dim by n2dim random ranarr.
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
ndim = 10
ranarr = 100.*uniform(size=(ndim))
ranarr2 = 100.*uniform(size=(ndim))
diff --git a/test/tst_masked2.py b/test/tst_masked2.py
index 1dcca92..5d00e8e 100755
--- a/test/tst_masked2.py
+++ b/test/tst_masked2.py
@@ -12,9 +12,9 @@ seterr(over='ignore') # don't print warning for overflow errors
# test automatic conversion of masked arrays, and
# packing/unpacking of short ints.
-FILE_NAME1 = tempfile.mktemp(".nc")
-FILE_NAME2 = tempfile.mktemp(".nc")
-FILE_NAME3 = tempfile.mktemp(".nc")
+FILE_NAME1 = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
+FILE_NAME2 = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
+FILE_NAME3 = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
datacheck1 =\
ma.array([0,5000.0,4000.0,0],dtype=np.float,mask=[True,False,False,True])
datacheck2 =\
diff --git a/test/tst_masked3.py b/test/tst_masked3.py
index a52bec7..7a5d09f 100755
--- a/test/tst_masked3.py
+++ b/test/tst_masked3.py
@@ -15,7 +15,7 @@ class SetAutoMaskTestBase(unittest.TestCase):
def setUp(self):
- self.testfile = tempfile.mktemp(".nc")
+ self.testfile = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
self.fillval = default_fillvals["i2"]
self.v = np.array([self.fillval, 5, 4, -9999], dtype = "i2")
@@ -137,7 +137,7 @@ class GlobalSetAutoMaskTest(unittest.TestCase):
def setUp(self):
- self.testfile = tempfile.mktemp(".nc")
+ self.testfile = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
f = Dataset(self.testfile, 'w')
diff --git a/test/tst_multifile.py b/test/tst_multifile.py
index ffe5106..3d75d4c 100644
--- a/test/tst_multifile.py
+++ b/test/tst_multifile.py
@@ -8,7 +8,7 @@ import tempfile, unittest, os, datetime
nx=100; ydim=5; zdim=1
nfiles = 10
ninc = nx/nfiles
-files = [tempfile.mktemp(".nc") for nfile in range(nfiles)]
+files = [tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name for nfile in range(nfiles)]
data = randint(0,10,size=(nx,ydim,zdim))
missval = 99
data[::10] = missval
@@ -66,7 +66,7 @@ class NonuniformTimeTestCase(unittest.TestCase):
ninc = 365
def setUp(self):
- self.files = [tempfile.mktemp(".nc") for nfile in range(2)]
+ self.files = [tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name for nfile in range(2)]
for nfile,file in enumerate(self.files):
f = Dataset(file,'w',format='NETCDF4_CLASSIC')
f.createDimension('time',None)
diff --git a/test/tst_multifile2.py b/test/tst_multifile2.py
index 34b21a1..d919d7a 100644
--- a/test/tst_multifile2.py
+++ b/test/tst_multifile2.py
@@ -8,7 +8,7 @@ import tempfile, unittest, os, datetime
nx=100; ydim=5; zdim=1
nfiles = 10
ninc = nx/nfiles
-files = [tempfile.mktemp(".nc") for nfile in range(nfiles)]
+files = [tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name for nfile in range(nfiles)]
data = randint(0,10,size=(nx,ydim,zdim))
missval = 99
data[::10] = missval
@@ -68,7 +68,7 @@ class NonuniformTimeTestCase(unittest.TestCase):
ninc = 365
def setUp(self):
- self.files = [tempfile.mktemp(".nc") for nfile in range(2)]
+ self.files = [tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name for nfile in range(2)]
for nfile,file in enumerate(self.files):
f = Dataset(file,'w',format='NETCDF4_CLASSIC')
f.createDimension('time',None)
diff --git a/test/tst_netcdftime.py b/test/tst_netcdftime.py
index d79b778..b6851b4 100644
--- a/test/tst_netcdftime.py
+++ b/test/tst_netcdftime.py
@@ -506,7 +506,7 @@ class TestDate2index(unittest.TestCase):
self.standardtime = self.TestTime(datetime(1950, 1, 1), 366, 24,
'hours since 1900-01-01', 'standard')
- self.file = tempfile.mktemp(".nc")
+ self.file = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
f = Dataset(self.file, 'w')
f.createDimension('time', None)
time = f.createVariable('time', float, ('time',))
diff --git a/test/tst_refcount.py b/test/tst_refcount.py
index f0ede72..f947922 100644
--- a/test/tst_refcount.py
+++ b/test/tst_refcount.py
@@ -1,6 +1,6 @@
import unittest, netCDF4, tempfile, os
-file_name = tempfile.mktemp(".nc")
+file_name = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
class RefCountTestCase(unittest.TestCase):
diff --git a/test/tst_rename.py b/test/tst_rename.py
index 42ed395..0b1cdef 100644
--- a/test/tst_rename.py
+++ b/test/tst_rename.py
@@ -9,7 +9,7 @@ from netCDF4 import __has_rename_grp__
# test changing dimension, variable names
# and deleting attributes.
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
LAT_NAME="lat"
LON_NAME="lon"
LON_NAME2 = "longitude"
diff --git a/test/tst_scalarvar.py b/test/tst_scalarvar.py
index f98e9bc..6a82574 100644
--- a/test/tst_scalarvar.py
+++ b/test/tst_scalarvar.py
@@ -10,7 +10,7 @@ import math
VAR_NAME='temp'
VAR_TYPE='f4'
VAR_VAL=math.pi
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
GROUP_NAME = 'subgroup'
# test scalar variable creation and retrieval.
diff --git a/test/tst_scaled.py b/test/tst_scaled.py
index 0d70e68..7f45a75 100755
--- a/test/tst_scaled.py
+++ b/test/tst_scaled.py
@@ -16,7 +16,7 @@ class SetAutoScaleTestBase(unittest.TestCase):
def setUp(self):
- self.testfile = tempfile.mktemp(".nc")
+ self.testfile = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
self.fillval = default_fillvals["i2"]
self.missing_value = -9999
@@ -184,7 +184,7 @@ class GlobalSetAutoScaleTest(unittest.TestCase):
def setUp(self):
- self.testfile = tempfile.mktemp(".nc")
+ self.testfile = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
f = Dataset(self.testfile, 'w')
diff --git a/test/tst_shape.py b/test/tst_shape.py
index 7f21fe6..952465f 100644
--- a/test/tst_shape.py
+++ b/test/tst_shape.py
@@ -2,7 +2,7 @@ from netCDF4 import Dataset
import tempfile, unittest, os
import numpy as np
-file_name = tempfile.mktemp(".nc")
+file_name = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
xdim=None; ydim=121; zdim=169
datashape = (ydim,zdim)
data = np.ones(datashape,dtype=np.float)
diff --git a/test/tst_slicing.py b/test/tst_slicing.py
index c156b4c..20331b8 100644
--- a/test/tst_slicing.py
+++ b/test/tst_slicing.py
@@ -5,7 +5,7 @@ assert_array_almost_equal
import tempfile, unittest, os, random
import numpy as np
-file_name = tempfile.mktemp(".nc")
+file_name = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
xdim=9; ydim=10; zdim=11
#seed(9) # fix seed
data = randint(0,10,size=(xdim,ydim,zdim)).astype('u1')
diff --git a/test/tst_types.py b/test/tst_types.py
index cc0d291..e673c3b 100644
--- a/test/tst_types.py
+++ b/test/tst_types.py
@@ -10,7 +10,7 @@ import netCDF4
# test primitive data types.
# create an n1dim by n2dim random ranarr.
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
n1dim = 5
n2dim = 10
ranarr = 100.*uniform(size=(n1dim,n2dim))
diff --git a/test/tst_unicode.py b/test/tst_unicode.py
index bcbe703..3f902cd 100644
--- a/test/tst_unicode.py
+++ b/test/tst_unicode.py
@@ -4,7 +4,7 @@ import sys, unittest, os, tempfile
netCDF4.default_encoding = 'utf-8'
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
ATT1 = u'\u03a0\u03a3\u03a9'
ATT2 = u'x\xb0'
ATT3 = [u'\u03a0',u'\u03a3',u'\u03a9']
diff --git a/test/tst_unicode3.py b/test/tst_unicode3.py
index bc20e2e..4661c19 100644
--- a/test/tst_unicode3.py
+++ b/test/tst_unicode3.py
@@ -4,7 +4,7 @@ import sys, unittest, os, tempfile
netCDF4.default_encoding = 'utf-8'
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
ATT1 = '\u03a0\u03a3\u03a9'
ATT2 = 'x\xb0'
ATT3 = ['\u03a0','\u03a3','\u03a9']
diff --git a/test/tst_unlimdim.py b/test/tst_unlimdim.py
index 85bd89e..9125571 100644
--- a/test/tst_unlimdim.py
+++ b/test/tst_unlimdim.py
@@ -15,7 +15,7 @@ n1dim = 4
n2dim = 10
n3dim = 8
ranarr = 100.*uniform(size=(n1dim,n2dim,n3dim))
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
class UnlimdimTestCase(unittest.TestCase):
diff --git a/test/tst_vars.py b/test/tst_vars.py
index c88ff6a..dffb93f 100644
--- a/test/tst_vars.py
+++ b/test/tst_vars.py
@@ -9,7 +9,7 @@ import netCDF4
# test variable creation.
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
VAR_DOUBLE_NAME="dummy_var"
VAR_SHORT_NAME='dummy_var_short'
VARNAMES = sorted([VAR_DOUBLE_NAME,VAR_SHORT_NAME])
diff --git a/test/tst_vlen.py b/test/tst_vlen.py
index 3837d3f..47c4e92 100644
--- a/test/tst_vlen.py
+++ b/test/tst_vlen.py
@@ -6,7 +6,7 @@ from netCDF4 import Dataset
import numpy as np
from numpy.testing import assert_array_equal
-FILE_NAME = tempfile.mktemp(".nc")
+FILE_NAME = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
VL_NAME = 'vlen_type'
VL_BASETYPE = np.int16
DIM1_NAME = 'lon'
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-grass/netcdf4-python.git
More information about the Pkg-grass-devel
mailing list