def from_file(self, filename, file_handle=None): """ Either opens a new h5 file for reading or accesses an already opened file via the given h5.Group handle. Reads all data from the three categories of attributes (incl. lists and dicts), ndarrays, and objects. Parameters ---------- filename: str file_handle: h5.Group, optional Returns ------- IOData """ if file_handle is None: h5file_group = h5py.File(filename, 'r') else: h5file_group = file_handle attributes = self.read_attributes(h5file_group) typename = attributes['__type'] del attributes['__type'] ndarrays = self.read_ndarrays(h5file_group) inner_objects = self.read_objects(h5file_group) return io.IOData(typename, attributes, ndarrays, inner_objects)
def NoneType_serialize(none_instance: None) -> 'IOData': """ Create an IOData instance to write `None` to file. """ import scqubits.io_utils.fileio as io attributes = {'None': 0} ndarrays: Dict[str, ndarray] = {} objects: Dict[str, object] = {} typename = 'NoneType' return io.IOData(typename, attributes, ndarrays, objects)
def listlike_serialize(listlike_instance: Union[List, Tuple]) -> 'IOData': """ Create an IOData instance from list data. """ import scqubits.io_utils.fileio as io attributes: Dict[str, Any] = {} ndarrays: Dict[str, ndarray] = {} objects: Dict[str, object] = {} typename = type(listlike_instance).__name__ for index, item in enumerate(listlike_instance): update_func = type_dispatch(item) attributes, ndarrays, objects = update_func(str(index), item, attributes, ndarrays, objects) return io.IOData(typename, attributes, ndarrays, objects)
def range_serialize(range_instance: range) -> "IOData": """ Create an IOData instance from range data. """ import scqubits.io_utils.fileio as io attributes = { "start": range_instance.start, "stop": range_instance.stop, "step": range_instance.step, } ndarrays: Dict[str, ndarray] = {} objects: Dict[str, object] = {} typename = type(range_instance).__name__ return io.IOData(typename, attributes, ndarrays, objects)
def dict_serialize(dict_instance: Dict[str, Any]) -> 'IOData': """ Create an IOData instance from dictionary data. """ import scqubits.io_utils.fileio as io dict_instance = utils.remove_nones(dict_instance) attributes: Dict[str, Any] = {} ndarrays: Dict[str, ndarray] = {} objects: Dict[str, object] = {} typename = 'dict' for name, content in dict_instance.items(): update_func = type_dispatch(content) attributes, ndarrays, objects = update_func(name, content, attributes, ndarrays, objects) return io.IOData(typename, attributes, ndarrays, objects)
def from_file(self, filename: str, file_handle: Group = None) -> io.IOData: """ Either opens a new h5 file for reading or accesses an already opened file via the given h5.Group handle. Reads all data from the three categories of attributes (incl. lists and dicts), ndarrays, and objects. """ if file_handle is None: h5file_group = h5py.File(filename, 'r') else: h5file_group = file_handle attributes = self.read_attributes(h5file_group) typename = attributes['__type'] assert isinstance(typename, str) del attributes['__type'] ndarrays = self.read_ndarrays(h5file_group) inner_objects = self.read_objects(h5file_group) return io.IOData(typename, attributes, ndarrays, inner_objects)
def serialize(self): """ Convert the content of the current class instance into IOData format. Returns ------- IOData """ import scqubits.io_utils.fileio as io typename = type(self).__name__ evec_count = len(self) qobj_dims = np.asarray(self[0].dims) qobj_shape = np.asarray(self[0].shape) io_attributes = {'evec_count': evec_count} io_ndarrays = {'evecs': np.asarray([utils.qt_ket_to_ndarray(qobj_ket) for qobj_ket in self]), 'qobj_dims': qobj_dims, 'qobj_shape': qobj_shape} return io.IOData(typename, io_attributes, io_ndarrays, objects=None)
def serialize(self) -> IOData: """ Convert the content of the current class instance into IOData format. """ import scqubits.io_utils.fileio as io typename = "NamedSlotsNdarray" io_attributes = None if self.dtype in [np.float_, np.complex_, np.int_]: io_ndarrays = {"input_array": self.view(np.ndarray)} objects = {"values_by_name": self._parameters.paramvals_by_name} else: io_ndarrays = None objects = { "values_by_name": self._parameters.paramvals_by_name, "input_array": self[:].tolist(), } return io.IOData(typename, io_attributes, io_ndarrays, objects=objects)
def from_file(self, filename: str, **kwargs) -> io.IOData: """ Returns ------- class instance generated from file data """ ext_attributes = self.read_attributes(filename) typename = ext_attributes['__type'] del ext_attributes['__type'] attributes, data_names, data_slices = self.process_metadict( ext_attributes) filename_stub, _ = os.path.splitext(filename) ndarrays = {} for index, dataname in enumerate(data_names): data_filename = filename_stub + '_' + dataname + '.csv' slices = data_slices[index] ndarrays[dataname] = self.read_data(data_filename, slices) return io.IOData(typename, attributes, ndarrays, objects=None)
def csc_matrix_serialize(csc_matrix_instance: csc_matrix) -> 'IOData': """ Create an IOData instance from dictionary data. """ import scqubits.io_utils.fileio as io attributes: Dict[str, Any] = {} ndarrays: Dict[str, ndarray] = {} objects: Dict[str, object] = {} typename = 'csc_matrix' csc_dict = { "indices": csc_matrix_instance.indices, "indptr": csc_matrix_instance.indptr, "shape": csc_matrix_instance.shape, "data": csc_matrix_instance.data } for name, content in csc_dict.items(): update_func = type_dispatch(content) attributes, ndarrays, objects = update_func(name, content, attributes, ndarrays, objects) return io.IOData(typename, attributes, ndarrays, objects)
def listlike_serialize(listlike_instance): """ Create an IOData instance from list data. Parameters ---------- listlike_instance: list or tuple Returns ------- IOData """ import scqubits.io_utils.fileio as io attributes = {} ndarrays = {} objects = {} typename = type(listlike_instance).__name__ for index, item in enumerate(listlike_instance): update_func = type_dispatch(item) attributes, ndarrays, objects = update_func(str(index), item, attributes, ndarrays, objects) return io.IOData(typename, attributes, ndarrays, objects)
def dict_serialize(dict_instance): """ Create an IOData instance from dictionary data. Parameters ---------- dict_instance: dict Returns ------- IOData """ import scqubits.io_utils.fileio as io dict_instance = utils.remove_nones(dict_instance) attributes = {} ndarrays = {} objects = {} typename = 'dict' for name, content in dict_instance.items(): update_func = type_dispatch(content) attributes, ndarrays, objects = update_func(name, content, attributes, ndarrays, objects) return io.IOData(typename, attributes, ndarrays, objects)