Confessional

[wpbonelli]

This thing is cursed like a large black cat heading you off on a crowded sidewalk, forcing you under a maintenance worker's ladder and onto a cracked, uneven stretch of pavement, upon which you trip and fall into the mirror-like edifice beside you, fracturing it. Uninjured, you pick yourself up sheepishly and note with relief the inability of the shattered glass to confront you with your own reflection, whose appearance beside you just before the cat entered the picture had filled you with shame at having written this library

Perhaps it's not too late to repent. To reject the forbidden fruit of state management and walk in the pure, functional light of truth. To follow xarray-dataclasses in considering the class a blueprint for constructing an xarray object. Wherein xattree will no longer invade your privacy, steal your property and lie to you about it, just ask you to opt into some metadata and mixins and automate an otherwise tedious transformation you'd have to manage yourself

The major difference between this project and xarray-dataclasses would be that the latter considers the dataclass a template to construct xarray objects from with the static new() method, and does not expect you to instantiate it. Where we would say, bring us your object model (maybe dataclasses/attrs/pydantic, we detect and accommodate) and we map it to/from datasets/trees

[wpbonelli]

More detail.

Right now we fuse attrs classes and xarray DataTrees into one object via runtime manipulation. This may be clever but it is deeply evil.

Instead we can simply bridge Python objects and xarray containers. This library as conversion layer.

Principles

• explicit over implicit (obj.to_datatree() over magic obj.data)
• protocols over inheritance (runtime checkable, more flexible)
• standard Python object lifecycle (hands off instance __dict__)
• no murky state management, just pure translation functions

Benefits

• better support for type checkers (no more "hidden" fields)
• will support attrs with slots=True for memory efficiency
• much simpler to develop, maintain, use, reason about

Salvage

Keep more or less unchanged:

• specification system
• field factories (dim, coord, array, etc)
• dimension inheritance

Throw away:

• datatree dict/list imposter classes (DataTreeList/DataTreeDict)
• horribly complicated bidirectional parent/child sync (bind_tree())
• the soul swap i.e. sucking __dict__ into the data tree (init_tree())

Adapt:

• dimension resolution
• array expansion from scalars
• tree construction from children

Example

from attrs import define, field
from xattree import DataTreeConvertible, dim, array

@define
class Data(DataTreeConvertible):
    rows: int = dim(default=10)
    cols: int = dim(default=10)
    data: np.ndarray = array(dims=("rows", "cols"), default=0.0)

data = Data()
tree = grid.to_datatree()
data = Data.from_datatree(tree)  # roundtrip