Skip to content

core

tuplify_json #

tuplify_json(obj: Mapping) -> Mapping

tuplify_json(obj: list) -> tuple

tuplify_json(obj)

Recursively converts lists within a Python object to tuples.

Source code in pydantic_zarr/core.py 
35
36
37
38
39
40
41
42
43
44
def tuplify_json(obj: object) -> object:
    """
    Recursively converts lists within a Python object to tuples.
    """
    if isinstance(obj, list):
        return tuple(tuplify_json(elem) for elem in obj)
    elif isinstance(obj, dict):
        return {k: tuplify_json(v) for k, v in obj.items()}
    else:
        return obj

parse_dtype_v2 #

parse_dtype_v2(value)

Convert the input to a NumPy dtype and either return the str attribute of that object or, if the dtype is a structured dtype, return the fields of that dtype as a list of tuples.

Parameters:

Name Type Description Default
value DTypeLike

A value that can be converted to a NumPy dtype.

 required

Returns:

Type Description
A Zarr V2-compatible encoding of the dtype.
References

See the Zarr V2 specification for more details on this encoding of data types.

Source code in pydantic_zarr/core.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
def parse_dtype_v2(value: npt.DTypeLike) -> str | list[tuple[Any, ...]]:
    """
    Convert the input to a NumPy dtype and either return the ``str`` attribute of that
    object or, if the dtype is a structured dtype, return the fields of that dtype as a list
    of tuples.

    Parameters
    ----------
    value : npt.DTypeLike
        A value that can be converted to a NumPy dtype.

    Returns
    -------

    A Zarr V2-compatible encoding of the dtype.

    References
    ----------
    See the [Zarr V2 specification](https://zarr-specs.readthedocs.io/en/latest/v2/v2.0.html#data-type-encoding)
    for more details on this encoding of data types.
    """
    # Assume that a non-string sequence represents a the Zarr V2 JSON form of a structured dtype.
    if isinstance(value, Sequence) and not isinstance(value, str):
        return [tuple(v) for v in value]
    else:
        np_dtype = np.dtype(value)
        if np_dtype.fields is not None:
            # This is a structured dtype, which must be converted to a list of tuples. Note that
            # this function recurses, because a structured dtype is parametrized by other dtypes.
            return [(k, parse_dtype_v2(v[0])) for k, v in np_dtype.fields.items()]
        else:
            return np_dtype.str

ensure_member_name #

ensure_member_name(data)

If the input is a string, then ensure that it is a valid name for a subnode in a zarr group

Source code in pydantic_zarr/core.py 
85
86
87
88
89
90
91
92
93
94
95
96
97
98
def ensure_member_name(data: Any) -> str:
    """
    If the input is a string, then ensure that it is a valid
    name for a subnode in a zarr group
    """
    if isinstance(data, str):
        if "/" in data:
            raise ValueError(
                f'Strings containing "/" are invalid. Got {data}, which violates this rule.'
            )
        if data in ("", ".", ".."):
            raise ValueError(f"The string {data} is not a valid member name.")
        return data
    raise TypeError(f"Expected a str, got {type(data)}.")

model_like #

model_like(a, b, exclude=None, include=None)

A similarity check for a pair pydantic.BaseModel, parametrized over included or excluded fields.

Source code in pydantic_zarr/core.py 
107
108
109
110
111
112
113
114
115
116
def model_like(a: BaseModel, b: BaseModel, exclude: IncEx = None, include: IncEx = None) -> bool:
    """
    A similarity check for a pair pydantic.BaseModel, parametrized over included or excluded fields.


    """

    a_dict = a.model_dump(exclude=exclude, include=include)
    b_dict = b.model_dump(exclude=exclude, include=include)
    return a_dict == b_dict

maybe_node #

maybe_node(store, path, *, zarr_format)

Return the array or group found at the store / path, if an array or group exists there. Otherwise return None.

Source code in pydantic_zarr/core.py 
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
def maybe_node(
    store: StoreLike, path: str, *, zarr_format: Literal[2, 3]
) -> zarr.Array | zarr.Group | None:
    """
    Return the array or group found at the store / path, if an array or group exists there.
    Otherwise return None.
    """
    from zarr.core.sync import sync
    from zarr.core.sync_group import get_node
    from zarr.storage._common import make_store_path

    # convert the storelike store argument to a Zarr store
    spath = sync(make_store_path(store, path=path))
    try:
        return get_node(spath.store, spath.path, zarr_format=zarr_format)
    except FileNotFoundError:
        return None

ensure_multiple #

ensure_multiple(data)

Ensure that there is at least one element in the sequence

Source code in pydantic_zarr/core.py 
140
141
142
143
144
145
146
def ensure_multiple(data: Sequence[T]) -> Sequence[T]:
    """
    Ensure that there is at least one element in the sequence
    """
    if len(data) < 1:
        raise ValueError("Invalid length. Expected 1 or more, got 0.")
    return data