More general parsing

This commit is contained in:
Andre Basche 2023-05-06 16:07:28 +02:00
parent 7dcb34559b
commit ea8f481b01
10 changed files with 165 additions and 128 deletions

View File

@ -12,7 +12,6 @@ from pyhon.parameter.fixed import HonParameterFixed
if TYPE_CHECKING: if TYPE_CHECKING:
from pyhon import HonAPI from pyhon import HonAPI
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
@ -30,6 +29,7 @@ class HonAppliance:
self._statistics: Dict = {} self._statistics: Dict = {}
self._attributes: Dict = {} self._attributes: Dict = {}
self._zone: int = zone self._zone: int = zone
self._additional_data = {}
try: try:
self._extra = importlib.import_module( self._extra = importlib.import_module(
@ -111,13 +111,17 @@ class HonAppliance:
def info(self): def info(self):
return self._info return self._info
@property
def additional_data(self):
return self._additional_data
@property @property
def zone(self) -> int: def zone(self) -> int:
return self._zone return self._zone
async def _recover_last_command_states(self, commands): async def _recover_last_command_states(self):
command_history = await self._api.command_history(self) command_history = await self._api.command_history(self)
for name, command in commands.items(): for name, command in self._commands.items():
last = next( last = next(
( (
index index
@ -129,8 +133,8 @@ class HonAppliance:
if last is None: if last is None:
continue continue
parameters = command_history[last].get("command", {}).get("parameters", {}) parameters = command_history[last].get("command", {}).get("parameters", {})
if command.programs and parameters.get("program"): if command.categories and parameters.get("category"):
command.program = parameters.pop("program").split(".")[-1].lower() command.category = parameters.pop("category").split(".")[-1].lower()
command = self.commands[name] command = self.commands[name]
for key, data in command.settings.items(): for key, data in command.settings.items():
if ( if (
@ -140,52 +144,50 @@ class HonAppliance:
with suppress(ValueError): with suppress(ValueError):
data.value = parameters.get(key) data.value = parameters.get(key)
def _get_categories(self, command, data):
categories = {}
for category, value in data.items():
result = self._get_command(value, command, category, categories)
if result:
if "PROGRAM" in category:
category = category.split(".")[-1].lower()
categories[category] = result[0]
if categories:
return [list(categories.values())[0]]
return []
def _get_commands(self, data):
commands = []
for command, value in data.items():
commands += self._get_command(value, command, "")
return {c.name: c for c in commands}
def _get_command(self, data, command="", category="", categories=None):
commands = []
if isinstance(data, dict):
if data.get("description") and data.get("protocolType", None):
commands += [
HonCommand(
command,
data,
self._api,
self,
category_name=category,
categories=categories,
)
]
else:
commands += self._get_categories(command, data)
else:
self._additional_data[command] = data
return commands
async def load_commands(self): async def load_commands(self):
raw = await self._api.load_commands(self) raw = await self._api.load_commands(self)
self._appliance_model = raw.pop("applianceModel") self._appliance_model = raw.pop("applianceModel")
for item in ["settings", "options", "dictionaryId"]: raw.pop("dictionaryId")
raw.pop(item) self._commands = self._get_commands(raw)
commands = {} await self._recover_last_command_states()
for command, attr in raw.items():
if "parameters" in attr:
commands[command] = HonCommand(command, attr, self._api, self)
elif "parameters" in attr[list(attr)[0]]:
multi = {}
for program, attr2 in attr.items():
program = program.split(".")[-1].lower()
cmd = HonCommand(
command,
attr2,
self._api,
self,
programs=multi,
program_name=program,
)
multi[program] = cmd
commands[command] = cmd
self._commands = commands
await self._recover_last_command_states(commands)
@property
def settings(self):
result = {}
for name, command in self._commands.items():
for key in command.setting_keys:
setting = command.settings.get(key, HonParameter(key, {}))
result[f"{name}.{key}"] = setting
if self._extra:
return self._extra.settings(result)
return result
@property
def parameters(self):
result = {}
for name, command in self._commands.items():
for key, parameter in (
command.parameters | command.ancillary_parameters
).items():
result.setdefault(name, {})[key] = parameter.value
return result
async def load_attributes(self): async def load_attributes(self):
self._attributes = await self._api.load_attributes(self) self._attributes = await self._api.load_attributes(self)
@ -198,12 +200,32 @@ class HonAppliance:
async def update(self): async def update(self):
await self.load_attributes() await self.load_attributes()
@property
def parameters(self):
result = {}
for name, command in self._commands.items():
for key, parameter in command.parameters.items():
result.setdefault(name, {})[key] = parameter.value
return result
@property
def settings(self):
result = {}
for name, command in self._commands.items():
for key in command.setting_keys:
setting = command.settings.get(key, HonParameter(key, {}, name))
result[f"{name}.{key}"] = setting
if self._extra:
return self._extra.settings(result)
return result
@property @property
def data(self): def data(self):
result = { result = {
"attributes": self.attributes, "attributes": self.attributes,
"appliance": self.info, "appliance": self.info,
"statistics": self.statistics, "statistics": self.statistics,
"additional_data": self._additional_data,
**self.parameters, **self.parameters,
} }
if self._extra: if self._extra:

View File

@ -18,97 +18,95 @@ class HonCommand:
attributes: Dict[str, Any], attributes: Dict[str, Any],
api: "HonAPI", api: "HonAPI",
appliance: "HonAppliance", appliance: "HonAppliance",
programs: Optional[Dict[str, "HonCommand"]] = None, categories: Optional[Dict[str, "HonCommand"]] = None,
program_name: str = "", category_name: str = "",
): ):
self._api: HonAPI = api self._api: HonAPI = api
self._appliance: "HonAppliance" = appliance self._appliance: "HonAppliance" = appliance
self._name: str = name self._name: str = name
self._programs: Optional[Dict[str, "HonCommand"]] = programs self._categories: Optional[Dict[str, "HonCommand"]] = categories
self._program_name: str = program_name self._category_name: str = category_name
self._description: str = attributes.get("description", "") self._description: str = attributes.pop("description", "")
self._parameters: Dict[str, HonParameter] = self._create_parameters( self._protocol_type: str = attributes.pop("protocolType", "")
attributes.get("parameters", {}) self._parameters: Dict[str, HonParameter] = {}
) self._data = {}
self._ancillary_parameters: Dict[str, HonParameter] = self._create_parameters( self._load_parameters(attributes)
attributes.get("ancillaryParameters", {})
)
def __repr__(self) -> str: def __repr__(self) -> str:
return f"{self._name} command" return f"{self._name} command"
def _create_parameters(self, parameters: Dict) -> Dict[str, HonParameter]: @property
result: Dict[str, HonParameter] = {} def name(self):
for parameter, attributes in parameters.items(): return self._name
if parameter == "zoneMap" and self._appliance.zone:
attributes["default"] = self._appliance.zone @property
match attributes.get("typology"): def data(self):
case "range": return self._data
result[parameter] = HonParameterRange(parameter, attributes)
case "enum":
result[parameter] = HonParameterEnum(parameter, attributes)
case "fixed":
result[parameter] = HonParameterFixed(parameter, attributes)
if self._programs:
result["program"] = HonParameterProgram("program", self)
return result
@property @property
def parameters(self) -> Dict[str, HonParameter]: def parameters(self) -> Dict[str, HonParameter]:
return self._parameters return self._parameters
@property def _load_parameters(self, attributes):
def ancillary_parameters(self) -> Dict[str, HonParameter]: for key, items in attributes.items():
return self._ancillary_parameters for name, data in items.items():
self._create_parameters(data, name, key)
def _create_parameters(self, data: Dict, name: str, parameter: str) -> None:
if name == "zoneMap" and self._appliance.zone:
data["default"] = self._appliance.zone
match data.get("typology"):
case "range":
self._parameters[name] = HonParameterRange(name, data, parameter)
case "enum":
self._parameters[name] = HonParameterEnum(name, data, parameter)
case "fixed":
self._parameters[name] = HonParameterFixed(name, data, parameter)
case _:
self._data[name] = data
return
if self._category_name:
if not self._categories:
self._parameters["program"] = HonParameterProgram("program", self, name)
def _parameters_by_group(self, group):
return {
name: v.value for name, v in self._parameters.items() if v.group == group
}
async def send(self) -> bool: async def send(self) -> bool:
params = {k: v.value for k, v in self._parameters.items()} params = self._parameters_by_group("parameters")
ancillary_params = {k: v.value for k, v in self._ancillary_parameters.items()} ancillary_params = self._parameters_by_group("ancillary_parameters")
return await self._api.send_command( return await self._api.send_command(
self._appliance, self._name, params, ancillary_params self._appliance, self._name, params, ancillary_params
) )
@property @property
def programs(self) -> Dict[str, "HonCommand"]: def categories(self) -> Dict[str, "HonCommand"]:
if self._programs is None: if self._categories is None:
return {} return {"_": self}
return self._programs return self._categories
@property @property
def program(self) -> str: def category(self) -> str:
return self._program_name return self._category_name
@program.setter @category.setter
def program(self, program: str) -> None: def category(self, category: str) -> None:
self._appliance.commands[self._name] = self.programs[program] self._appliance.commands[self._name] = self.categories[category]
def _get_settings_keys(self, command: Optional["HonCommand"] = None) -> List[str]:
if command is None:
command = self
keys = []
for key, parameter in (
command._parameters | command._ancillary_parameters
).items():
if key not in keys:
keys.append(key)
return keys
@property @property
def setting_keys(self) -> List[str]: def setting_keys(self) -> List[str]:
if not self._programs: return list(
return self._get_settings_keys() {param for cmd in self.categories.values() for param in cmd.parameters}
result = [ )
key
for cmd in self._programs.values()
for key in self._get_settings_keys(cmd)
]
return list(set(result + ["program"]))
@property @property
def settings(self) -> Dict[str, HonParameter]: def settings(self) -> Dict[str, HonParameter]:
return { result = {}
s: param for command in self.categories.values():
for s in self.setting_keys for name, parameter in command.parameters.items():
if (param := self._parameters.get(s)) is not None if name in result:
or (param := self._ancillary_parameters.get(s)) is not None continue
} result[name] = parameter
return result

View File

@ -109,6 +109,18 @@ class HonAPI:
return activity return activity
return {} return {}
async def appliance_model(self, appliance: HonAppliance) -> Dict:
url: str = f"{const.API_URL}/commands/v1/appliance-model"
params: Dict = {
"code": appliance.info["code"],
"macAddress": appliance.mac_address,
}
async with self._hon.get(url, params=params) as response:
result: Dict = await response.json()
if result and (activity := result.get("attributes")):
return activity
return {}
async def load_attributes(self, appliance: HonAppliance) -> Dict: async def load_attributes(self, appliance: HonAppliance) -> Dict:
params: Dict = { params: Dict = {
"macAddress": appliance.mac_address, "macAddress": appliance.mac_address,
@ -161,7 +173,7 @@ class HonAPI:
return False return False
async def appliance_configuration(self) -> Dict: async def appliance_configuration(self) -> Dict:
url: str = f"{const.API_URL}/config/v1/appliance-configuration" url: str = f"{const.API_URL}/config/v1/program-list-rules"
async with self._hon_anonymous.get(url) as response: async with self._hon_anonymous.get(url) as response:
result: Dict = await response.json() result: Dict = await response.json()
if result and (data := result.get("payload")): if result and (data := result.get("payload")):

View File

@ -48,7 +48,7 @@ def pretty_print(data, key="", intend=0, is_list=False, whitespace=" "):
def get_parameter(command, parameter): def get_parameter(command, parameter):
if programs := command.programs: if programs := command.categories:
for program in programs.values(): for program in programs.values():
if data := program.settings.get(parameter): if data := program.settings.get(parameter):
return data return data

View File

@ -2,12 +2,13 @@ from typing import Dict, Any, List
class HonParameter: class HonParameter:
def __init__(self, key: str, attributes: Dict[str, Any]) -> None: def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
self._key = key self._key = key
self._category: str = attributes.get("category", "") self._category: str = attributes.get("category", "")
self._typology: str = attributes.get("typology", "") self._typology: str = attributes.get("typology", "")
self._mandatory: int = attributes.get("mandatory", 0) self._mandatory: int = attributes.get("mandatory", 0)
self._value: str | float = "" self._value: str | float = ""
self._group: str = group
@property @property
def key(self) -> str: def key(self) -> str:
@ -19,7 +20,7 @@ class HonParameter:
@property @property
def values(self) -> List[str]: def values(self) -> List[str]:
return list(str(self.value)) return [str(self.value)]
@property @property
def category(self) -> str: def category(self) -> str:
@ -32,3 +33,7 @@ class HonParameter:
@property @property
def mandatory(self) -> int: def mandatory(self) -> int:
return self._mandatory return self._mandatory
@property
def group(self) -> str:
return self._group

View File

@ -4,8 +4,8 @@ from pyhon.parameter.base import HonParameter
class HonParameterEnum(HonParameter): class HonParameterEnum(HonParameter):
def __init__(self, key: str, attributes: Dict[str, Any]) -> None: def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
super().__init__(key, attributes) super().__init__(key, attributes, group)
self._default = attributes.get("defaultValue") self._default = attributes.get("defaultValue")
self._value = self._default or "0" self._value = self._default or "0"
self._values: List[str] = attributes.get("enumValues", []) self._values: List[str] = attributes.get("enumValues", [])

View File

@ -4,8 +4,8 @@ from pyhon.parameter.base import HonParameter
class HonParameterFixed(HonParameter): class HonParameterFixed(HonParameter):
def __init__(self, key: str, attributes: Dict[str, Any]) -> None: def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
super().__init__(key, attributes) super().__init__(key, attributes, group)
self._value = attributes.get("fixedValue", None) self._value = attributes.get("fixedValue", None)
def __repr__(self) -> str: def __repr__(self) -> str:

View File

@ -9,11 +9,11 @@ if TYPE_CHECKING:
class HonParameterProgram(HonParameterEnum): class HonParameterProgram(HonParameterEnum):
_FILTER = ["iot_recipe", "iot_guided"] _FILTER = ["iot_recipe", "iot_guided"]
def __init__(self, key: str, command: "HonCommand") -> None: def __init__(self, key: str, command: "HonCommand", group: str) -> None:
super().__init__(key, {}) super().__init__(key, {}, group)
self._command = command self._command = command
self._value: str = command.program self._value: str = command.category
self._programs: Dict[str, "HonCommand"] = command.programs self._programs: Dict[str, "HonCommand"] = command.categories
self._typology: str = "enum" self._typology: str = "enum"
@property @property

View File

@ -11,8 +11,8 @@ def str_to_float(string: str | float) -> float:
class HonParameterRange(HonParameter): class HonParameterRange(HonParameter):
def __init__(self, key: str, attributes: Dict[str, Any]) -> None: def __init__(self, key: str, attributes: Dict[str, Any], group: str) -> None:
super().__init__(key, attributes) super().__init__(key, attributes, group)
self._min: float = str_to_float(attributes["minimumValue"]) self._min: float = str_to_float(attributes["minimumValue"])
self._max: float = str_to_float(attributes["maximumValue"]) self._max: float = str_to_float(attributes["maximumValue"])
self._step: float = str_to_float(attributes["incrementValue"]) self._step: float = str_to_float(attributes["incrementValue"])

View File

@ -7,7 +7,7 @@ with open("README.md", "r") as f:
setup( setup(
name="pyhOn", name="pyhOn",
version="0.9.1", version="0.10.0b0",
author="Andre Basche", author="Andre Basche",
description="Control hOn devices with python", description="Control hOn devices with python",
long_description=long_description, long_description=long_description,