Classes | |
| class | ComponentCube |
| class | HierarchicalBlendData |
| class | ScarletBlendData |
| class | ScarletComponentBaseData |
| class | ScarletComponentData |
| class | ScarletFactorizedComponentData |
| class | ScarletModelData |
| class | ScarletSourceData |
Functions | |
| dict[str, Any] | _numpy_to_json (np.ndarray arr) |
| np.ndarray | _json_to_numpy (dict[str, Any] encoded_dict) |
| dict[str, Any]|None | _encode_metadata (dict[str, Any]|None metadata) |
| dict[str, Any]|None | _decode_metadata (dict[str, Any]|None metadata) |
| Any | _extract_from_metadata (Any data, dict[str, Any]|None metadata, str key) |
Variables | |
| logger = logging.getLogger(__name__) | |
Function Documentation
◆ _decode_metadata()
|
protected |
Unpack metadata from a JSON compatible format.
Parameters
----------
metadata :
The metadata to be unpacked.
Returns
-------
result :
The unpacked metadata.
Definition at line 116 of file io.py.
116def _decode_metadata(metadata: dict[str, Any] | None) -> dict[str, Any] | None:
117 """Unpack metadata from a JSON compatible format.
118
119 Parameters
120 ----------
121 metadata :
122 The metadata to be unpacked.
123
124 Returns
125 -------
126 result :
127 The unpacked metadata.
128 """
129 if metadata is None:
130 return None
131 if "array_keys" in metadata:
132 for key in metadata["array_keys"]:
133 # Default dtype is float32 to support legacy models
134 dtype = metadata.pop(f"{key}_dtype", "float32")
135 shape = metadata.pop(f"{key}_shape", None)
136 if shape is None and f"{key}Shape" in metadata:
137 # Support legacy models that use `keyShape`
138 shape = metadata[f"{key}Shape"]
139 decoded = _json_to_numpy({"dtype": dtype, "shape": shape, "data": metadata[key]})
140 metadata[key] = decoded
141 # Remove the array keys after decoding
142 del metadata["array_keys"]
143 return metadata
144
145
◆ _encode_metadata()
|
protected |
Pack metadata into a JSON compatible format.
Parameters
----------
metadata :
The metadata to be packed.
Returns
-------
result :
The packed metadata.
Definition at line 85 of file io.py.
85def _encode_metadata(metadata: dict[str, Any] | None) -> dict[str, Any] | None:
86 """Pack metadata into a JSON compatible format.
87
88 Parameters
89 ----------
90 metadata :
91 The metadata to be packed.
92
93 Returns
94 -------
95 result :
96 The packed metadata.
97 """
98 if metadata is None:
99 return None
100 encoded = {}
101 array_keys = []
102 for key, value in metadata.items():
103 if isinstance(value, np.ndarray):
104 _encoded = _numpy_to_json(value)
105 encoded[key] = _encoded["data"]
106 encoded[f"{key}_shape"] = _encoded["shape"]
107 encoded[f"{key}_dtype"] = _encoded["dtype"]
108 array_keys.append(key)
109 else:
110 encoded[key] = value
111 if len(array_keys) > 0:
112 encoded["array_keys"] = array_keys
113 return encoded
114
115
◆ _extract_from_metadata()
|
protected |
Extract relevant information from the metadata.
Parameters
----------
data :
The data to extract information from.
metadata :
The metadata to extract information from.
key :
The key to extract from the metadata.
Returns
-------
result :
A tuple containing the extracted data and metadata.
Definition at line 146 of file io.py.
150) -> Any:
151 """Extract relevant information from the metadata.
152
153 Parameters
154 ----------
155 data :
156 The data to extract information from.
157 metadata :
158 The metadata to extract information from.
159 key :
160 The key to extract from the metadata.
161
162 Returns
163 -------
164 result :
165 A tuple containing the extracted data and metadata.
166 """
167 if data is not None:
168 return data
169 if metadata is None:
170 raise ValueError("Both data and metadata cannot be None")
171 if key not in metadata:
172 raise ValueError(f"'{key}' not found in metadata")
173 return metadata[key]
174
175
176@dataclass(kw_only=True)
◆ _json_to_numpy()
|
protected |
Decode a JSON dictionary back to a numpy array.
Parameters
----------
encoded_dict :
Dictionary with 'dtype', 'shape', and 'data' keys.
Returns
-------
result :
The reconstructed numpy array.
Definition at line 66 of file io.py.
66def _json_to_numpy(encoded_dict: dict[str, Any]) -> np.ndarray:
67 """
68 Decode a JSON dictionary back to a numpy array.
69
70 Parameters
71 ----------
72 encoded_dict :
73 Dictionary with 'dtype', 'shape', and 'data' keys.
74
75 Returns
76 -------
77 result :
78 The reconstructed numpy array.
79 """
80 if "dtype" not in encoded_dict or "shape" not in encoded_dict or "data" not in encoded_dict:
81 raise ValueError("Encoded dictionary must contain 'dtype', 'shape', and 'data' keys.")
82 return np.array(encoded_dict["data"], dtype=encoded_dict["dtype"]).reshape(encoded_dict["shape"])
83
84
◆ _numpy_to_json()
|
protected |
Encode a numpy array as JSON-serializable dictionary.
Parameters
----------
arr :
The numpy array to encode
Returns
-------
result :
A JSON formatted dictionary containing the dtype, shape,
and data of the array.
Definition at line 32 of file io.py.
32def _numpy_to_json(arr: np.ndarray) -> dict[str, Any]:
33 """
34 Encode a numpy array as JSON-serializable dictionary.
35
36 Parameters
37 ----------
38 arr :
39 The numpy array to encode
40
41 Returns
42 -------
43 result :
44 A JSON formatted dictionary containing the dtype, shape,
45 and data of the array.
46 """
47 # Convert to native Python types for JSON serialization
48 flattened = arr.flatten()
49
50 # Convert numpy scalars to native Python types
51 if np.issubdtype(arr.dtype, np.integer):
52 data: list = [int(x) for x in flattened]
53 elif np.issubdtype(arr.dtype, np.floating):
54 data = [float(x) for x in flattened]
55 elif np.issubdtype(arr.dtype, np.complexfloating):
56 data = [complex(x) for x in flattened]
57 elif np.issubdtype(arr.dtype, np.bool_):
58 data = [bool(x) for x in flattened]
59 else:
60 # For other types (strings, objects, etc.), convert to string
61 data = [str(x) for x in flattened]
62
63 return {"dtype": str(arr.dtype), "shape": tuple(arr.shape), "data": data}
64
65
Variable Documentation
◆ logger
Generated on Sun Aug 31 2025 07:01:51 for LSST Applications by
1.13.2