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]
