def _linear(self, default): """Create and assign a linear dimension.""" missing_key = ["increment", "count"] for item in missing_key: if default[item] is None: raise KeyError(f"Missing a required `{item}` key from the " "LinearDimension object.") validate(default["count"], "count", int) return LinearDimension(**default)
def _to(self, unit="", equivalencies=None): r"""Convert the unit to given value `unit`.""" unit = validate(unit, "unit", str) if equivalencies is None: self._unit = ScalarQuantity(unit, self._unit).quantity.unit else: self._unit = ScalarQuantity(unit).quantity.unit self._equivalencies = equivalencies
def set_component_labels(self, component_labels): """ Assign an array of strings, based on the number of components. If no label is provided, a default values, :math:`['', '', N_k]`, is assigned. If the number of component labels does not match the total number of components, a warning is raised and the inconsistency is resolved by appropriate truncating or adding the required number of strings. """ n = self._quantity_type.p if component_labels is None: self._component_labels = ["" for i in range(n)] return validate(component_labels, "component_labels", list) component_length = len(component_labels) if component_length == n: self._component_labels = component_labels return warning_statement = ( f"The number of component labels, {component_length}, is not equal" f" to the number of components, {n}. The inconsistency is resolved" f" by appropriate truncation or addition of the strings.") warnings.warn(warning_statement) if component_length > n: self._component_labels = component_labels[:n] return lables = ["" for i in range(n)] for i, item in enumerate(component_labels): lables[i] = item self._component_labels = lables return
def count(self, value): value = validate(value, "count", int) if self.type in functional_dimension: self.subtype._count = value self.subtype._get_coordinates() return if value > self.count: raise ValueError( (f"Cannot set count, {value}, more than the number of " f"coordinates, {self.count}, for monotonic and labeled" " dimensions.")) if value < self.count: warnings.warn( f"The number of coordinates, {self.count}, are truncated " f"to {value}.") self.subtype._count = value
def parse_dict(dictionary): """Parse a CSDM compliant python dictionary and return a CSDM object. Args: dictionary: A CSDM compliant python dictionary. """ key_list_root = dictionary.keys() if "CSDM" in key_list_root: raise KeyError("'CSDM' is not a valid keyword. Did you mean 'csdm'?") if "csdm" not in key_list_root: raise KeyError("Missing a required `csdm` key.") # inside csdm object optional_keys = [ "read_only", "timestamp", "geographic_coordinate", "application", "tags", "description", ] required_keys = ["version"] all_keys = optional_keys + required_keys key_list_csdm = list(dictionary["csdm"].keys()) key_list_csdm_lower_case = [item.lower() for item in key_list_csdm] for i in range(len(key_list_csdm)): if key_list_csdm[i] not in all_keys and key_list_csdm_lower_case[ i] in all_keys: raise KeyError((f"{key_list_csdm[i]} is not a valid keyword. " f"Did you mean '{key_list_csdm_lower_case[i]}'?")) for item in required_keys: if item not in key_list_csdm: raise KeyError(f"Missing a required `{item}` key.") _version = dictionary["csdm"]["version"] validate(_version, "version", str) if "filename" in dictionary.keys(): filename = dictionary["filename"] else: filename = None csdm = CSDM(filename=filename, version=_version) if "timestamp" in dictionary["csdm"].keys(): _timestamp = dictionary["csdm"]["timestamp"] validate(_timestamp, "timestamp", str) csdm._timestamp = _timestamp if "dimensions" in key_list_csdm: for dim in dictionary["csdm"]["dimensions"]: csdm.add_dimension(dim) if "dependent_variables" in key_list_csdm: for dat in dictionary["csdm"]["dependent_variables"]: csdm.add_dependent_variable(dat) n_points = [item.count for item in csdm.dimensions] if n_points != []: csdm._reshape(n_points[::-1]) for key in optional_keys: if key in key_list_csdm: setattr(csdm, "_" + key, dictionary["csdm"][key]) return csdm
def description(self, value): self._description = validate(value, "description", str)
def label(self, label=""): self._label = validate(label, "label", str)
def application(self, value): self._application = validate(value, "application", dict)
def encoding(self, value): self._encoding = validate(value, "encoding", str, check_encoding)
def name(self, value): self._name = validate(value, "name", str)
def read_only(self, value): self._read_only = validate(value, "read_only", bool)
def tags(self, value): self._tags = validate(value, "tags", list)
def origin_offset(self, value): allowed_types = (Quantity, str, ScalarQuantity) value = validate(value, "origin_offset", allowed_types) self._origin_offset = ScalarQuantity(value, self._unit).quantity
def coordinates_offset(self, value): allowed_types = (Quantity, str, ScalarQuantity) value = validate(value, "coordinates_offset", allowed_types) value = ScalarQuantity(value, self._unit).quantity self._coordinates_offset = value