atlas-python 0.16.2__tar.gz → 0.16.3__tar.gz

{atlas_python-0.16.2 → atlas_python-0.16.3}/Cargo.lock

@@ -71,7 +71,7 @@ dependencies = [
 
 [[package]]
 name = "atlas-python"
-version = "0.16.2"
+version = "0.16.3"
 dependencies = [
  "atlas-rust",
  "ndarray",
@@ -86,7 +86,7 @@ dependencies = [
 
 [[package]]
 name = "atlas-rust"
-version = "0.16.2"
+version = "0.16.3"
 dependencies = [
  "array-format",
  "async-trait",

{atlas_python-0.16.2 → atlas_python-0.16.3}/Cargo.toml

@@ -5,7 +5,7 @@ members = ["atlas-python"]
 # Registry name on crates.io (`atlas` is taken). The library is still
 # imported as `atlas` — see `[lib]` below.
 name = "atlas-rust"
-version = "0.16.2"
+version = "0.16.3"
 edition = "2024"
 description = "Single-file immutable store for thousands of N-dimensional datasets, local or on object storage."
 license = "Apache-2.0"

{atlas_python-0.16.2 → atlas_python-0.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atlas-python
-Version: 0.16.2
+Version: 0.16.3
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3

{atlas_python-0.16.2 → atlas_python-0.16.3}/atlas-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "atlas-python"
-version = "0.16.2"
+version = "0.16.3"
 edition = "2021"
 readme = "README.md"
 

{atlas_python-0.16.2 → atlas_python-0.16.3}/atlas-python/docs/cli.md

@@ -30,7 +30,7 @@ Every subcommand takes `--json` and `--log-file PATH`, plus the remote flags
 ```bash
 $ atlas create /data/nc /data/collection --skip-unsupported --log-file ingest.log
 $ cat ingest.log
-2026-09-01 14:30:41 INFO    atlas.cli: atlas 0.16.2: create /data/nc ...
+2026-09-01 14:30:41 INFO    atlas.cli: atlas 0.16.3: create /data/nc ...
 2026-09-01 14:30:41 INFO    atlas.ops: ingesting 2 file(s) into /data/collection
 2026-09-01 14:30:41 WARNING atlas.ops: /data/nc/buoy.nc: skipped array 'flag' of dtype bool: numpy dtype dtype('bool') is not supported by atlas (supported: ...)
 2026-09-01 14:30:41 INFO    atlas.ops: wrote 1 dataset(s); skipped 0 file(s) and 1 array(s)
@@ -66,6 +66,7 @@ A failure part-way leaves no collection, and not a partial one.
 | `--open-chunks MODE` | How files are read: `auto`, `native`, `none`, or a JSON dict |
 | `--chunks JSON` | Override the stored chunk shape, `'{"temperature": [64, 64]}'` |
 | `--skip-errors` | Skip files that fail instead of abandoning the collection |
+| `--no-decode-times` | Keep a time axis as raw numbers, for a calendar that decodes to cftime |
 | `--skip-unsupported` | Leave out an array of an unsupported dtype, and keep the rest of the dataset |
 | `-q`, `--quiet` | Do not list a file as it lands |
 

{atlas_python-0.16.2 → atlas_python-0.16.3}/atlas-python/docs/guides/dtypes.md

@@ -17,6 +17,71 @@ What a NetCDF variable becomes when `atlas create` ingests it.
 `atlas show` prints the atlas name, so a `datetime64[ns]` variable appears as
 `timestamp_nanoseconds`.
 
+### Calendars that decode to cftime
+
+xarray decodes a time axis to `datetime64[ns]` only when the calendar allows
+it. A Julian, `360_day`, or `noleap` calendar, or a date outside the
+`datetime64[ns]` range, decodes to a `cftime` object instead. Those arrive as
+a numpy `object` array, and atlas cannot store one:
+
+```text
+atlas: profile.nc: variable 'JULD' holds cftime objects (DatetimeJulian),
+which atlas cannot store...
+```
+
+Atlas refuses by default rather than guess, because two conversions exist and
+they differ by 13 days. Pick one.
+
+**Convert to the exact instant.** This is almost always what you want:
+
+```bash
+atlas create /data/nc /data/collection --convert-calendar
+```
+
+```python
+atlas.create("/data/nc", dest, convert_calendar=True)
+```
+
+The axis becomes `timestamp_nanoseconds`, and every value keeps the moment it
+named. A Julian `1973-02-25 18:15` becomes the Gregorian `1973-03-10 18:15`.
+Those are one instant under two calendars. cftime maps between them through
+the Julian Day, so nothing is approximated.
+
+**Keep the raw numbers.** The axis stores as an integer, with its `units` and
+`calendar` attributes beside it. A reader decodes it later with
+`cftime.num2date`:
+
+```bash
+atlas create /data/nc /data/collection --no-decode-times
+```
+
+**Drop the axis.** `--skip-unsupported` leaves the time array out, and keeps
+the rest of the dataset.
+
+#### Two conversions, 13 days apart
+
+The Julian calendar takes a leap year every four years. The Gregorian calendar
+drops three of those every four centuries. The gap grows by about three days
+per 400 years, and holds at 13 days from 1900 to 2100.
+
+| Conversion | Julian 2024-01-01 becomes | It keeps |
+|---|---|---|
+| `--convert-calendar` | 2024-01-14 | the instant |
+| `xr.Dataset.convert_calendar("standard")` | 2024-01-01 | the labels |
+
+The xarray method keeps the year, month, and day, which moves the moment by 13
+days. Use it only when the labels matter more than the instant.
+
+#### Two limits
+
+**An artificial calendar names no instant.** A `360_day`, `noleap`, or
+`all_leap` year is a model convention with no place on a real timeline.
+`--convert-calendar` raises for one. Use `--no-decode-times` instead.
+
+**A nanosecond timestamp spans 1677-09-21 to 2262-04-11.** A date outside that
+raises. numpy wraps such a date in silence, so atlas checks every value before
+it stores one.
+
 ### datetime and timedelta
 
 Atlas supports the `[ns]` resolution of `datetime64` alone. It rejects every

{atlas_python-0.16.2 → atlas_python-0.16.3}/atlas-python/src/writer.rs

@@ -322,7 +322,7 @@ impl PyDatasetWriter {
                     String::from_utf8_lossy(&b).into_owned()
                 } else {
                     return Err(PyTypeError::new_err(format!(
-                        "string array element must be str or bytes, got {:?}",
+                        "array {name:?}: a string element must be str or bytes, got {:?}",
                         bound.get_type().name()?
                     )));
                 };

{atlas_python-0.16.2 → atlas_python-0.16.3}/atlas-python/tests/test_ops.py

@@ -215,6 +215,151 @@ def test_a_clean_ingest_reports_no_skipped_arrays(netcdf_dir, tmp_path):
     assert result["skipped_arrays"] == []
 
 
+# ── cftime calendars ─────────────────────────────────────────────────
+
+
+@pytest.fixture
+def netcdf_dir_with_a_julian_calendar(tmp_path):
+    """A time axis xarray decodes to cftime, not to datetime64."""
+    import cftime
+
+    d = tmp_path / "nc"
+    d.mkdir()
+    times = [cftime.DatetimeJulian(2024, 1, i + 1) for i in range(4)]
+    xr.Dataset(
+        {"temp": ("time", np.arange(4, dtype=np.float32))},
+        coords={"time": ("time", times)},
+    ).to_netcdf(d / "julian.nc")
+    return d
+
+
+def test_a_cftime_axis_reports_the_variable_and_the_remedy(
+    netcdf_dir_with_a_julian_calendar, tmp_path
+):
+    with pytest.raises(atlas.AtlasError) as exc:
+        atlas.create(netcdf_dir_with_a_julian_calendar, str(tmp_path / "c"))
+
+    message = str(exc.value)
+    assert "'time'" in message, "the message must name the variable"
+    assert "DatetimeJulian" in message
+    assert "decode_times=False" in message
+
+
+def test_decode_times_false_stores_a_cftime_axis_as_raw_numbers(
+    netcdf_dir_with_a_julian_calendar, tmp_path
+):
+    dest = tmp_path / "c"
+    atlas.create(netcdf_dir_with_a_julian_calendar, str(dest), decode_times=False)
+
+    arrays = {a["name"]: a for a in atlas.describe(str(dest), "julian.nc")["arrays"]}
+    assert arrays["time"]["dtype"] == "int64"
+    # The units and the calendar survive, so a reader can decode the numbers.
+    assert arrays["time"]["attributes"]["calendar"] == "julian"
+    assert "days since" in arrays["time"]["attributes"]["units"]
+    assert arrays["temp"]["dtype"] == "float32"
+
+
+def test_a_cftime_axis_can_be_skipped_per_array(
+    netcdf_dir_with_a_julian_calendar, tmp_path
+):
+    dest = tmp_path / "c"
+    result = atlas.create(
+        netcdf_dir_with_a_julian_calendar, str(dest), on_unsupported="skip"
+    )
+
+    assert [s["array"] for s in result["skipped_arrays"]] == ["time"]
+    assert [a["name"] for a in atlas.describe(str(dest), "julian.nc")["arrays"]] == [
+        "temp"
+    ]
+
+
+def test_convert_calendar_keeps_the_exact_instant(
+    netcdf_dir_with_a_julian_calendar, tmp_path
+):
+    """A Julian label and its Gregorian label name one moment, 13 days apart."""
+    dest = tmp_path / "c"
+    atlas.create(netcdf_dir_with_a_julian_calendar, str(dest), convert_calendar=True)
+
+    arrays = {a["name"]: a for a in atlas.describe(str(dest), "julian.nc")["arrays"]}
+    assert arrays["time"]["dtype"] == "timestamp_nanoseconds"
+
+    # The fixture holds Julian 2024-01-01 through 2024-01-04. The same instants
+    # carry the Gregorian labels 2024-01-14 through 2024-01-17.
+    first = np.datetime64(arrays["time"]["stats"]["min"], "ns")
+    last = np.datetime64(arrays["time"]["stats"]["max"], "ns")
+    assert first == np.datetime64("2024-01-14T00:00:00")
+    assert last == np.datetime64("2024-01-17T00:00:00")
+
+
+def test_convert_calendar_matches_a_per_element_conversion(
+    netcdf_dir_with_a_julian_calendar,
+):
+    """The array-at-once conversion must equal the obvious slow one."""
+    from atlas.xarray import _cftime_to_datetime64
+
+    ds = xr.open_dataset(netcdf_dir_with_a_julian_calendar / "julian.nc")
+    values = np.asarray(ds["time"].values)
+
+    fast = _cftime_to_datetime64("time", values)
+    slow = np.array(
+        [
+            np.datetime64(v.change_calendar("proleptic_gregorian").isoformat(), "ns")
+            for v in values
+        ]
+    )
+    assert np.array_equal(fast, slow)
+
+
+def test_an_artificial_calendar_has_no_exact_gregorian_date(tmp_path):
+    """A 360_day year names no real instant, so no conversion exists."""
+    import cftime
+
+    from atlas.xarray import _cftime_to_datetime64
+
+    values = np.array([cftime.Datetime360Day(2024, 2, 30)], dtype=object)
+    with pytest.raises(NotImplementedError, match="360_day"):
+        _cftime_to_datetime64("time", values)
+
+
+def test_a_date_outside_the_nanosecond_range_is_refused_not_wrapped(tmp_path):
+    """numpy wraps such a date in silence. Atlas must not pass one on."""
+    import cftime
+
+    from atlas.xarray import _cftime_to_datetime64
+
+    for year in (1600, 2300):
+        values = np.array([cftime.DatetimeJulian(year, 1, 1)], dtype=object)
+        with pytest.raises(NotImplementedError, match="outside the range"):
+            _cftime_to_datetime64("time", values)
+
+
+def test_convert_calendar_leaves_a_normal_time_axis_alone(netcdf_dir, tmp_path):
+    dest = tmp_path / "c"
+    atlas.create(netcdf_dir, str(dest), convert_calendar=True)
+    arrays = {a["name"]: a for a in atlas.describe(str(dest), "2024-01.nc")["arrays"]}
+    assert arrays["time"]["dtype"] == "timestamp_nanoseconds"
+
+
+def test_an_object_array_of_something_else_is_refused_clearly(tmp_path):
+    """numpy reports `object` for both a string array and this one."""
+    from atlas.xarray import _reject_unstorable_object_array
+
+    var = xr.DataArray(np.array([{"a": 1}, {"b": 2}], dtype=object), dims=["x"])
+    with pytest.raises(NotImplementedError, match="object array of dict"):
+        _reject_unstorable_object_array("payload", var)
+
+
+def test_a_real_string_array_still_passes_the_object_check(tmp_path):
+    from atlas.xarray import _reject_unstorable_object_array
+
+    # A missing cell must not be mistaken for an unsupported element.
+    var = xr.DataArray(np.array([None, "b", "c"], dtype=object), dims=["x"])
+    _reject_unstorable_object_array("label", var)
+
+    empty = xr.DataArray(np.array([], dtype=object), dims=["x"])
+    _reject_unstorable_object_array("empty", empty)
+
+
 # ── the log file ─────────────────────────────────────────────────────
 
 

{atlas_python-0.16.2 → atlas_python-0.16.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "atlas-python"
-version = "0.16.2"
+version = "0.16.3"
 description = "Python bindings for the ATLAS array store"
 readme = "README.md"
 requires-python = ">=3.10"

{atlas_python-0.16.2 → atlas_python-0.16.3}/python/atlas/__init__.pyi

@@ -62,6 +62,8 @@ def create(
     chunks: Optional[dict[str, Sequence[int]]] = None,
     open_chunks: Union[str, dict[str, int], None] = "auto",
     chunk_size: str = "128MiB",
+    decode_times: bool = True,
+    convert_calendar: bool = False,
     on_error: str = "stop",
     on_unsupported: str = "stop",
     progress: Optional[Callable[[str], None]] = None,
@@ -114,6 +116,16 @@ def create(
         chunk_size: The block size ``"auto"`` aims at, as a dask size string.
             It is about the memory ceiling per variable during ingest. It
             defaults to ``"128MiB"``.
+        decode_times: How xarray reads a time axis. Under the default, a
+            calendar it cannot map to ``datetime64[ns]``, such as a Julian
+            one, decodes to cftime objects, which atlas cannot store. Set it
+            false to keep the raw numbers, with their ``units`` and
+            ``calendar`` attributes.
+        convert_calendar: Turn a cftime axis into exact Gregorian timestamps.
+            Each one keeps its instant, so a Julian ``1973-02-25`` becomes the
+            Gregorian ``1973-03-10`` that names the same moment. A calendar
+            with no real instant, such as ``360_day``, and a date outside the
+            nanosecond range both raise instead.
         on_error: ``"stop"`` is the default. It abandons the whole collection
             on the first bad file. ``"skip"`` records that file and continues.
         on_unsupported: What one array of an unsupported dtype costs.

{atlas_python-0.16.2 → atlas_python-0.16.3}/python/atlas/__main__.py

@@ -1,9 +1,9 @@
 """Runs the command as ``python -m atlas``.
 
 The ``atlas`` console script needs its directory on ``PATH``. This entry point
-does not. It works in any environment that can import the package, which makes
-it the reliable form inside a container, a CI job, or a virtual environment
-nobody activated.
+does not. It works in any environment that can import the package. That makes
+it the reliable form inside a container, in a CI job, and in a virtual
+environment nobody activated.
 """
 
 import sys

{atlas_python-0.16.2 → atlas_python-0.16.3}/python/atlas/_cli.py

@@ -161,6 +161,8 @@ def cmd_create(args: argparse.Namespace) -> int:
         chunks=chunks,
         open_chunks=open_chunks,
         chunk_size=args.chunk_size,
+        decode_times=not args.no_decode_times,
+        convert_calendar=args.convert_calendar,
         on_error="skip" if args.skip_errors else "stop",
         on_unsupported="skip" if args.skip_unsupported else "stop",
         progress=progress,
@@ -360,6 +362,23 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="skip files that fail instead of abandoning the collection",
     )
+    p.add_argument(
+        "--convert-calendar",
+        action="store_true",
+        help=(
+            "turn a cftime axis into exact Gregorian timestamps. Each one "
+            "keeps its instant, so a Julian date moves to the Gregorian date "
+            "that names the same moment"
+        ),
+    )
+    p.add_argument(
+        "--no-decode-times",
+        action="store_true",
+        help=(
+            "keep a time axis as raw numbers. Use it for a calendar xarray "
+            "decodes to cftime, such as Julian, which atlas cannot store"
+        ),
+    )
     p.add_argument(
         "--skip-unsupported",
         action="store_true",

{atlas_python-0.16.2 → atlas_python-0.16.3}/python/atlas/_ops.py

@@ -105,6 +105,8 @@ def create(
     chunks: Optional[dict[str, Sequence[int]]] = None,
     open_chunks: Any = "auto",
     chunk_size: str = DEFAULT_CHUNK_SIZE,
+    decode_times: bool = True,
+    convert_calendar: bool = False,
     on_error: str = "stop",
     on_unsupported: str = "stop",
     progress: Optional[Any] = None,
@@ -137,6 +139,17 @@ def create(
     `on_error` then handles. `"skip"` leaves that array out, and the rest of
     the dataset still lands.
 
+    `decode_times` controls how xarray reads a time axis. Under the default,
+    a calendar it cannot map to `datetime64[ns]`, such as a Julian one,
+    decodes to cftime objects, which atlas cannot store. Set it false to keep
+    the raw numbers and their `units` and `calendar` attributes instead.
+
+    `convert_calendar` turns those cftime objects into exact Gregorian
+    timestamps. Each one keeps its instant, so a Julian 1973-02-25 becomes the
+    Gregorian 1973-03-10 that names the same moment. A calendar with no real
+    instant, such as `360_day`, and a date outside the nanosecond range both
+    raise instead.
+
     `progress` takes each file name as that file lands.
 
     Returns a summary. How many datasets landed, which files the run skipped,
@@ -150,6 +163,8 @@ def create(
         )
 
     open_kwargs = _open_kwargs(open_chunks)
+    if not decode_times:
+        open_kwargs["decode_times"] = False
 
     import dask
     import xarray as xr
@@ -185,7 +200,13 @@ def create(
                     # before the file closes.
                     with xr.open_dataset(path, **open_kwargs) as ds:
                         left_out = _xarray._write_xarray_dataset(
-                            writer, ds, name, chunks, None, on_unsupported
+                            writer,
+                            ds,
+                            name,
+                            chunks,
+                            None,
+                            on_unsupported,
+                            convert_calendar,
                         )
                     for item in left_out:
                         _LOG.warning(

{atlas_python-0.16.2 → atlas_python-0.16.3}/python/atlas/xarray.py

@@ -244,6 +244,152 @@ def _fill_missing_strings(block: np.ndarray, fill: str) -> tuple[np.ndarray, int
     return np.where(mask, fill, block), n
 
 
+# How far into an object array to look for a real value. Enough to tell a
+# string array from an array of something else, and cheap on a dask block.
+_OBJECT_SAMPLE = 64
+
+
+def _sample_object_element(var: Any) -> Any:
+    """The first value of an object array that is no missing marker.
+
+    This scans a bounded prefix, and computes one dask block at most.
+    """
+    data = var.data
+    if _is_dask_array(data):
+        import dask
+
+        (head,) = dask.compute(data.reshape(-1)[:_OBJECT_SAMPLE])
+    else:
+        head = np.asarray(data).reshape(-1)[:_OBJECT_SAMPLE]
+    for value in head:
+        if not _is_missing_str(value):
+            return value
+    return None
+
+
+# The span of `datetime64[ns]`. A value outside it wraps silently, so every
+# conversion is checked against these first.
+_STAMP_MIN = np.datetime64("1677-09-21T00:12:44", "us")
+_STAMP_MAX = np.datetime64("2262-04-11T23:47:16", "us")
+
+
+def _is_cftime(value: Any) -> bool:
+    """Whether `value` is a cftime datetime, without importing cftime."""
+    return type(value).__module__.split(".")[0] == "cftime"
+
+
+def _cftime_to_datetime64(var_name: str, values: np.ndarray) -> np.ndarray:
+    """The same instants as `values`, on the proleptic Gregorian calendar.
+
+    cftime maps between two real-world calendars through the Julian Day, so
+    the instant survives exactly. A Julian label and a Gregorian label of one
+    instant differ by 13 days this century, and name the same moment.
+
+    The conversion runs on the whole array at once. One call per element costs
+    a few hundred times more.
+    """
+    import cftime
+
+    flat = np.ravel(values)
+    missing = np.fromiter(
+        (_is_missing_str(v) for v in flat), dtype=bool, count=flat.size
+    )
+    present = flat[~missing]
+    out = np.full(flat.size, np.datetime64("NaT", "us"), dtype="datetime64[us]")
+    if present.size == 0:
+        return out.reshape(values.shape).astype("datetime64[ns]")
+
+    calendar = present[0].calendar
+    try:
+        # The Unix epoch, written on the source calendar. Elapsed time from it
+        # is then elapsed time from the Gregorian epoch.
+        epoch = cftime.datetime(
+            1970, 1, 1, calendar="proleptic_gregorian"
+        ).change_calendar(calendar)
+    except ValueError as exc:
+        raise NotImplementedError(
+            f"variable {var_name!r} uses the {calendar!r} calendar, which names "
+            f"no real instant, so no exact Gregorian date exists. Only a "
+            f"real-world calendar converts. Pass decode_times=False to keep "
+            f"the raw numbers"
+        ) from exc
+
+    units = "microseconds since " + epoch.strftime("%Y-%m-%d %H:%M:%S")
+    micros = np.rint(
+        np.asarray(cftime.date2num(present, units, calendar=calendar), dtype="float64")
+    ).astype("int64")
+    stamps = np.datetime64(0, "us") + micros.astype("timedelta64[us]")
+
+    outside = (stamps < _STAMP_MIN) | (stamps > _STAMP_MAX)
+    if outside.any():
+        worst = stamps[outside][0]
+        raise NotImplementedError(
+            f"variable {var_name!r} holds {int(outside.sum())} date(s) outside "
+            f"the range of a nanosecond timestamp, such as {worst}. Atlas "
+            f"stores {_STAMP_MIN} to {_STAMP_MAX}. Pass decode_times=False to "
+            f"keep the raw numbers"
+        )
+
+    out[~missing] = stamps
+    return out.reshape(values.shape).astype("datetime64[ns]")
+
+
+def with_converted_calendars(ds: "xr.Dataset") -> "xr.Dataset":
+    """A copy of `ds` with every cftime array turned into `datetime64[ns]`.
+
+    Each timestamp keeps its instant. The calendar label changes, so a Julian
+    1973-02-25 becomes the Gregorian 1973-03-10 that names the same moment.
+    """
+    replacements = {}
+    for name in list(ds.coords) + list(ds.data_vars):
+        var = ds[name]
+        if np.dtype(var.dtype).kind != "O":
+            continue
+        sample = _sample_object_element(var)
+        if sample is None or not _is_cftime(sample):
+            continue
+        values = _cftime_to_datetime64(str(name), np.asarray(var.values))
+        replacements[str(name)] = (var.dims, values, dict(var.attrs))
+
+    if not replacements:
+        return ds
+    out = ds.copy()
+    for name, entry in replacements.items():
+        # The (dims, data, attrs) tuple assigns without importing xarray here.
+        out[name] = entry
+        _LOG.info("converted %r from cftime to an exact Gregorian timestamp", name)
+    return out
+
+
+def _reject_unstorable_object_array(var_name: str, var: Any) -> None:
+    """Raises when an object array holds something atlas cannot store.
+
+    Atlas stores an object array as a string array. numpy reports only
+    `object` for the dtype, so the element type settles what the array really
+    holds. A missing marker and an empty array both pass, because the string
+    path handles them.
+    """
+    sample = _sample_object_element(var)
+    if sample is None or isinstance(sample, (str, bytes)):
+        return
+
+    kind = type(sample)
+    if _is_cftime(sample):
+        raise NotImplementedError(
+            f"variable {var_name!r} holds cftime objects ({kind.__name__}), "
+            f"which atlas cannot store. xarray decodes a calendar it cannot "
+            f"map to datetime64[ns], such as a Julian one, into cftime. Pass "
+            f"convert_calendar=True, or --convert-calendar, for the exact "
+            f"Gregorian instant. Pass decode_times=False to keep the raw "
+            f"numbers and their units instead"
+        )
+    raise NotImplementedError(
+        f"variable {var_name!r} is an object array of {kind.__name__}. Atlas "
+        f"stores an object array as a string, so every element must be a str "
+        f"or bytes"
+    )
+
+
 def _is_dask_array(arr: Any) -> bool:
     """True when `arr` is a `dask.array.Array`. False when dask is absent."""
     try:
@@ -372,6 +518,7 @@ def _write_xarray_to_view(
     chunks: Optional[dict[str, Sequence[int]]] = None,
     fill_value: Any = None,
     on_unsupported: str = "stop",
+    convert_calendar: bool = False,
 ) -> list[dict[str, str]]:
     """Fills an empty `DatasetWriter` from an xarray Dataset.
 
@@ -389,6 +536,9 @@ def _write_xarray_to_view(
             f"on_unsupported must be 'stop' or 'skip', got {on_unsupported!r}"
         )
 
+    if convert_calendar:
+        ds = with_converted_calendars(ds)
+
     coord_names = [str(n) for n in ds.coords.keys()]
     order = coord_names + [str(n) for n in ds.data_vars.keys()]
 
@@ -399,7 +549,14 @@ def _write_xarray_to_view(
     skipped: list[dict[str, str]] = []
     for var_name in order:
         try:
-            dtypes[var_name] = _np_to_atlas_dtype(np.dtype(ds[var_name].dtype))
+            np_dtype = np.dtype(ds[var_name].dtype)
+            atlas_dtype = _np_to_atlas_dtype(np_dtype)
+            # An object array maps to string on the dtype alone. Check what it
+            # really holds before any array is defined, so a skip leaves no
+            # half-written array behind.
+            if np_dtype.kind == "O":
+                _reject_unstorable_object_array(var_name, ds[var_name])
+            dtypes[var_name] = atlas_dtype
         except NotImplementedError as exc:
             if on_unsupported == "stop":
                 raise
@@ -525,6 +682,7 @@ def _write_xarray_dataset(
     chunks: Optional[dict[str, Sequence[int]]] = None,
     fill_value: Any = None,
     on_unsupported: str = "stop",
+    convert_calendar: bool = False,
 ) -> list[dict[str, str]]:
     """Writes an ``xarray.Dataset`` into an open writer, under ``name``.
 
@@ -543,6 +701,7 @@ def _write_xarray_dataset(
             chunks=chunks,
             fill_value=fill_value,
             on_unsupported=on_unsupported,
+            convert_calendar=convert_calendar,
         )
     except BaseException:
         dataset_writer.abort()