def test_special_cases(): with pytest.raises(ValueError): modes.get_mode("does-not-exist") with pytest.raises(ValueError): modes.get_mode(object()) assert modes.get_mode(None) is None
def unpack(packed: dict) -> Record: kwargs = {} data = packed["data"] if np.isrealobj(data): data = data.astype("float") kwargs["data"] = data for a in attr.fields(Record): k = a.name if a.type == str: kwargs[k] = packed[k] elif a.type == Optional[str]: kwargs[k] = packed.get(k, None) try: mode = modes.get_mode(packed["mode"]) except ValueError: mode = None warnings.warn("unknown mode encountered while unpacking record") kwargs["mode"] = mode kwargs["session_info"] = json.loads(packed["session_info"]) kwargs["data_info"] = json.loads(packed["data_info"]) kwargs["sample_times"] = packed.get("sample_times", None) assert len(kwargs["data"]) == len(kwargs["data_info"]) return Record(**kwargs)
def unpack(packed: dict) -> Record: kwargs = {} data = packed["data"] if np.isrealobj(data): data = data.astype("float") kwargs["data"] = data for a in attr.fields(Record): k = a.name if a.type == str: kwargs[k] = packed[k] elif a.type == Optional[str]: kwargs[k] = packed.get(k, None) kwargs["mode"] = modes.get_mode(packed["mode"]) kwargs["session_info"] = json.loads(packed["session_info"]) kwargs["data_info"] = json.loads(packed["data_info"]) kwargs["sample_times"] = packed.get("sample_times", None) assert len(kwargs["data"]) == len(kwargs["data_info"]) return Record(**kwargs)
def get_reg(value, mode=None): if isinstance(value, Register): return value elif isinstance(value, int): match_fun = partial(_match_reg_by_addr, value) elif isinstance(value, str): match_fun = partial(_match_reg_by_name, value) else: raise ValueError mode = get_mode(mode) matches = [] for reg in REGISTERS: if match_fun(reg): if mode is None or reg.modes is None or mode in reg.modes: matches.append(reg) if len(matches) < 1: raise ValueError("unknown reg: {}".format(value)) if len(matches) > 1: raise ValueError("ambiguous reg: {}".format(value)) return matches[0]
def _setup_session(self, config): if isinstance(config, dict): cmd = deepcopy(config) log.warning("setup with raw dict config - you're on your own") else: cmd = get_dict_for_config(config) try: self._mode = get_mode(cmd["cmd"].lower().replace("_data", "")) except ValueError: self._mode = None self._sweeps_per_frame = cmd.get("sweeps_per_frame", 16) self._num_sensors = len(cmd["sensors"]) cmd["output_format"] = "json+binary" self._session_cmd = cmd info = self._init_session() if "update_rate" in cmd: self._link.timeout = 1 / cmd["update_rate"] + self._link.DEFAULT_TIMEOUT else: self._link.timeout = self._link.DEFAULT_TIMEOUT log.debug("setup session") return info
def load(dump, mode=None): if mode is None: mode = json.loads(dump)["mode"] mode = get_mode(mode) config = MODE_TO_CONFIG_CLASS_MAP[mode]() config._loads(dump) return config
def test_get_modes(): with pytest.raises(ValueError): modes.get_mode("does-not-exist") with pytest.raises(ValueError): modes.get_mode(object()) assert modes.get_mode(None) is None assert modes.get_mode("sparse") == modes.Mode.SPARSE assert modes.get_mode("SPARSE") == modes.Mode.SPARSE assert modes.get_mode(modes.Mode.SPARSE) == modes.Mode.SPARSE
def test_positive(mode): assert modes.get_mode(mode) == mode assert modes.get_mode(mode.name.lower()) == mode assert modes.get_mode(mode.name.upper()) == mode assert modes.get_mode(mode.name.title()) == mode assert modes.get_mode(mode.value.lower()) == mode assert modes.get_mode(mode.value.upper()) == mode assert modes.get_mode(mode.value.title()) == mode
def get_config_key_to_reg_map(mode): # {config_key: reg} mode = get_mode(mode) config = configs.MODE_TO_CONFIG_CLASS_MAP[mode]() m = {} for config_key, reg_name in CONFIG_TO_STRIPPED_REG_NAME_MAP.items(): if reg_name is None: continue if not hasattr(config, config_key): continue m[config_key] = get_reg(reg_name, mode) return m
def decode_output_buffer(buffer, mode, sweeps_per_frame=None): mode = get_mode(mode) if mode == Mode.POWER_BINS: return np.frombuffer(buffer, dtype="<u2").astype("float") elif mode == Mode.ENVELOPE: return np.frombuffer(buffer, dtype="<u2").astype("float") elif mode == Mode.IQ: data = np.frombuffer(buffer, dtype="<i2").astype("float") return data.reshape((-1, 2)).view(dtype="complex").flatten() elif mode == Mode.SPARSE: data = np.frombuffer(buffer, dtype="<u2").astype("float") data = data.reshape((sweeps_per_frame, -1)) return data else: raise NotImplementedError
def unpack(packed: dict) -> Record: kwargs = {} for a in attr.fields(Record): k = a.name if a.type == str: kwargs[k] = packed[k] elif a.type == Optional[str]: kwargs[k] = packed.get(k, None) kwargs["mode"] = modes.get_mode(packed["mode"]) kwargs["session_info"] = json.loads(packed["session_info"]) kwargs["data"] = packed["data"] kwargs["data_info"] = json.loads(packed["data_info"]) assert len(kwargs["data"]) == len(kwargs["data_info"]) return Record(**kwargs)
def get_dict_for_config(config): d = {} d["cmd"] = get_mode(config.mode).value.lower() + "_data" for config_key, cmd_key in CONFIG_TO_CMD_KEY_MAP.items(): config_val = getattr(config, config_key, None) if config_val is None: continue if isinstance(config_val, bool): cmd_val = int(config_val) elif isinstance(config_val, enum.Enum): if hasattr(config_val, "json_value"): cmd_val = config_val.json_value else: cmd_val = config_val.value else: cmd_val = config_val d[cmd_key] = cmd_val return d
def load(self, obj, value): assert get_mode(value) == self.value
def load_yaml(): global REGISTERS if REGISTERS is not None: return here = os.path.dirname(os.path.realpath(__file__)) yaml_filename = os.path.abspath( os.path.join(here, "../../data/regmap.yaml")) with open(yaml_filename, "r") as f: s = f.read() raw_regs = yaml.load(s, Loader=yaml.Loader) REGISTERS = [] for raw_name, raw_reg in raw_regs.items(): raw_modes = raw_reg.get("modes", None) if raw_modes is None or raw_modes == "None": modes = None elif isinstance(raw_modes, str): try: modes = [get_mode(raw_modes)] except ValueError: continue else: # assumed to be a list modes = [] for m in raw_modes: try: modes.append(get_mode(m)) except ValueError: pass if len(modes) == 0: continue full_name = raw_name.strip().lower() try: prefix, stripped_name = full_name.split("_", 1) except ValueError: stripped_name = full_name else: if prefix in PREFIX_TO_MODE_MAP.keys(): mode = PREFIX_TO_MODE_MAP[prefix] if mode is None: continue assert PREFIX_TO_MODE_MAP[prefix] == modes[0] and len( modes) == 1 else: stripped_name = full_name addr = raw_reg["address"] assert type(addr) == int readable, writable = [ c in raw_reg.get("access", "rw").strip().lower() for c in "rw" ] category = Category(raw_reg["category"].strip().lower()) data_type = DataType(raw_reg["type"].strip().lower()) reg = Register( full_name=full_name, stripped_name=stripped_name, addr=addr, modes=modes, readable=readable, writable=writable, category=category, data_type=data_type, ) try: reg.float_scale = float(raw_reg["scale"]) except (KeyError, ValueError): pass else: assert reg.data_type == DataType.INT32 if data_type == DataType.ENUM: enum_values = { str(k).upper(): int(d["value"]) for k, d in raw_reg["values"].items() } reg.enum = enum.IntEnum(full_name + "_enum", enum_values) if data_type == DataType.BITSET: flags = {} masks = {} for k, v in [(str(k).upper(), int(d["value"])) for k, d in raw_reg["bits"].items()]: if v == 0: continue if v & (v - 1) == 0: # is power of 2 flags[k] = v else: masks[k] = v reg.bitset_flags = enum.IntFlag(full_name + "_bitset_flags", flags) reg.bitset_masks = enum.IntEnum(full_name + "_bitset_masks", masks) REGISTERS.append(reg)
def get_regs_for_mode(mode): if mode is None: raise ValueError mode = get_mode(mode) return [reg for reg in REGISTERS if reg.modes is None or mode in reg.modes]