deadcade/pyhOn
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

More general parsing

Browse source
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
Show stats Download patch file Download diff file Expand all files Collapse all files

118
pyhon/appliance.py
View file

@ -12,7 +12,6 @@ from pyhon.parameter.fixed import HonParameterFixed
if TYPE_CHECKING:
from pyhon import HonAPI
_LOGGER = logging.getLogger(__name__)
@ -30,6 +29,7 @@ class HonAppliance:
self._statistics: Dict = {}
self._attributes: Dict = {}
self._zone: int = zone
self._additional_data = {}
try:
self._extra = importlib.import_module(
@ -111,13 +111,17 @@ class HonAppliance:
def info(self):
return self._info
@property
def additional_data(self):
return self._additional_data
@property
def zone(self) -> int:
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)
for name, command in commands.items():
for name, command in self._commands.items():
last = next(
(
index
@ -129,8 +133,8 @@ class HonAppliance:
if last is None:
continue
parameters = command_history[last].get("command", {}).get("parameters", {})
if command.programs and parameters.get("program"):
command.program = parameters.pop("program").split(".")[-1].lower()
if command.categories and parameters.get("category"):
command.category = parameters.pop("category").split(".")[-1].lower()
command = self.commands[name]
for key, data in command.settings.items():
if (
@ -140,52 +144,50 @@ class HonAppliance:
with suppress(ValueError):
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):
raw = await self._api.load_commands(self)
self._appliance_model = raw.pop("applianceModel")
for item in ["settings", "options", "dictionaryId"]:
raw.pop(item)
commands = {}
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
raw.pop("dictionaryId")
self._commands = self._get_commands(raw)
await self._recover_last_command_states()
async def load_attributes(self):
self._attributes = await self._api.load_attributes(self)
@ -198,12 +200,32 @@ class HonAppliance:
async def update(self):
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
def data(self):
result = {
"attributes": self.attributes,
"appliance": self.info,
"statistics": self.statistics,
"additional_data": self._additional_data,
**self.parameters,
}
if self._extra:

128
pyhon/commands.py
View file

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

14
pyhon/connection/api.py
View file

@ -109,6 +109,18 @@ class HonAPI:
return activity
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:
params: Dict = {
"macAddress": appliance.mac_address,
@ -161,7 +173,7 @@ class HonAPI:
return False
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:
result: Dict = await response.json()
if result and (data := result.get("payload")):

2
pyhon/helper.py
View file

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

9
pyhon/parameter/base.py
View file

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

4
pyhon/parameter/enum.py
View file

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

4
pyhon/parameter/fixed.py
View file

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

8
pyhon/parameter/program.py
View file

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

4
pyhon/parameter/range.py
View file

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

2
setup.py
View file

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