def empty_leaves(
e: lxml.etree.Element,
tags: typing.List[str] = None,
):
for e_it in reversed(list(e)):
empty_leaves(e_it)
if len(e) == 0 and not e.text and not e.tail and (tags is None
or e.tag in tags):
e.drop_tree()
def from_xml(cls, obj: lxml.etree.Element) -> PdoInfo:
name = obj.xpath("Name")[0].text
index = _from_hex(obj.xpath("Index")[0].text)
return cls(
name=name,
index=index,
# element=obj,
fixed=obj.attrib.get("Fixed", None) == "1",
mandatory=obj.attrib.get("Mandatory", None) == "1",
entries=[PdoEntry.from_xml(entry) for entry in obj.xpath("Entry")],
)
def replace_color_on_target_shape(shape_xml: lxml.etree.Element,
new_color: str) -> lxml.etree.Element:
"""
Changes the color of an [Open Office Xml Shape](http://officeopenxml.com/drwShape.php)
"""
new_fill = lxml.etree.Element("solidFill")
lxml.etree.SubElement(new_fill, "srbgClr", {"val": new_color})
fill_tags = ['noFill', 'blipFill', 'gradFill', 'pattFill', 'solidFill']
props = shape_xml.find('.//{*}spPr')
for child in props.getchildren():
if any(re.search('{*}' + r, child.tag) for r in fill_tags):
current_nsmap = child.nsmap
current_index = props.index(child)
current_prefix = child.prefix
current_ns = current_nsmap.get(current_prefix, None)
new_fill = lxml.etree.Element(lxml.etree.QName(
current_ns, "solidFill"),
nsmap=current_nsmap)
lxml.etree.SubElement(new_fill,
lxml.etree.QName(current_ns, "srgbClr"),
{"val": new_color},
nsmap=current_nsmap)
child.getparent().remove(child)
props.insert(current_index, new_fill)
return shape_xml
def _single_text_or_none(obj: lxml.etree.Element, path: str) -> Optional[str]:
items = obj.xpath(path)
if len(items) > 1:
raise RuntimeError(f"Expected only 0 or 1 elements in xpath: {items}")
try:
item, = items
except ValueError:
return None
return item.text
def _process_steps(cur_step: lxml.etree.Element, sbs: SchemaBuilderState, prev_steps,
is_nested: bool = False) -> List[Step]:
steps = []
while len(cur_step) > 0:
cur_step = cur_step[0]
if cur_step.get('type') == 'kairos_control_parallel':
child_step = xpath('b:statement[@name="DO"]/b:block', cur_step)
new_steps = Schema._process_steps(child_step, sbs, prev_steps, is_nested=True)
elif cur_step.get('type') in ('kairos_control_xor', 'kairos_control_linear'):
# TODO: implement me!
child_step = xpath('b:statement[@name="DO"]/b:block', cur_step)
new_steps = Schema._process_steps(child_step, sbs, prev_steps, is_nested=True)
else:
new_steps = [Step.from_xml_block(cur_step, sbs)]
cur_step = xpath('b:next/b:block', cur_step)
steps.append(new_steps)
if not is_nested and prev_steps is not None:
sbs.gen_order(prev_steps, new_steps, order_type='before_after')
prev_steps = new_steps
return list(itertools.chain.from_iterable(steps))
def get_tabular_data_from_element(
self,
element: lxml.etree.Element,
column_name_mapper: ColumnListMapperFunction = None,
known_percentages: List[str] = []) -> pd.DataFrame:
headings = element.xpath(self.headings_xpath)
if column_name_mapper:
headings = list(column_name_mapper(headings))
data_rows_dom = element.xpath(self.data_rows_xpath)
data_rows = [[
postprocessing.try_parse(y,
headings[index],
known_percentages=known_percentages)
for index, y in enumerate(x.xpath(self.data_cell_xpath))
] for x in data_rows_dom]
fg_data = pd.DataFrame(data_rows, columns=headings)
return fg_data
def from_xml(cls, obj: lxml.etree.Element) -> TerminalInfo:
txpdos = [PdoInfo.from_xml(pdo) for pdo in obj.xpath("TxPdo")]
rxpdos = [PdoInfo.from_xml(pdo) for pdo in obj.xpath("RxPdo")]
mappings = [
SlaveMappings(
name="All PDOs",
output_indices=[pdo.index for pdo in rxpdos],
input_indices=[pdo.index for pdo in txpdos],
)
]
mappings += [
SlaveMappings.from_xml(sm) for sm in obj.xpath(
"Info/VendorSpecific/TwinCAT/AlternativeSmMapping")
]
return TerminalInfo(
name=obj.xpath("Type")[0].text,
revision=obj.xpath("Type")[0].attrib.get("RevisionNo", ""),
txpdo=txpdos,
rxpdo=rxpdos,
mappings=mappings,
# element=obj,
)
def _process_tcs(cur_tc: lxml.etree.Element, sbs: SchemaBuilderState):
while len(cur_tc) > 0:
cur_tc = cur_tc[0]
assert cur_tc.get('type') == 'kairos_control_type_constraint'
var_id = xpath('b:field[@name="VAR"]', cur_tc)[0].get('id')
var_types_str = xpath('b:field[@name="TYPES"]', cur_tc)[0].text
var_ref_str = xpath('b:field[@name="REF"]', cur_tc)[0].text
assert var_id in sbs.vars
var_types = None if var_types_str is None else [var_type.strip() for var_type in var_types_str.split(',')]
var_ref = None if var_ref_str is None else var_ref_str.strip()
sbs.vars[var_id]['types'] = var_types
sbs.vars[var_id]['ref'] = var_ref
cur_tc = xpath('b:next/b:block', cur_tc)
def extract_id_from_row(fg_row: lxml.etree.Element,
param_name: str) -> Optional[int]:
try:
anchor_tags = fg_row.xpath('td//a')
for anchor_tag in anchor_tags:
href = anchor_tag.get('href')
if href and '?' in href:
qs_params = href.split('?')[1].split('&')
values = [
qs_param.split('=')[1] for qs_param in qs_params
if qs_param.split('=')[0].lower() == param_name
]
if values:
return int(values[0])
except:
pass
return None
def from_xml_block(cur_step: lxml.etree.Element, sbs: SchemaBuilderState):
valid_prefix = 'kairos_event_'
block_type = cur_step.get('type')
assert block_type.startswith(valid_prefix)
# Get step type, name, and comment
step_type = block_type[len(valid_prefix):]
step_type_id = f'kairos:Primitives/Events/{step_type}'
step_name = xpath('b:field[@name="step_name"]', cur_step)[0].text
step_id = sbs.gen_unique_id(step_name, f'{sbs.schema_id}/Steps')
step_comment_block = xpath('b:comment', cur_step)
if len(step_comment_block) == 1:
step_comment = step_comment_block[0].text
else:
step_comment = None
# Get step slots
slots_blocks = xpath('b:value[starts-with(@name,"part_")]/b:block/b:value', cur_step)
step_slots = []
for slot_block in slots_blocks:
# Check for 'disabled' flag
if slot_block.getparent().get('disabled') is not None:
continue
slot_role = slot_block.get('name')
slot_vars = xpath('.//b:block[@type="variables_get"]/b:field', slot_block)
slot_role_id = f'{step_type_id}/Slots/{slot_role}'
slot_id_prefix = f'{step_id}/Slots'
for sv in slot_vars:
slot_var_id = sv.get('id')
slot_name = sbs.vars[slot_var_id]['name']
slot_id = sbs.gen_unique_id(slot_name, slot_id_prefix)
slot_name = slot_id[len(slot_id_prefix) + 1:] # to ensure slot names are unique across the step
slot_ont_types = events_args[step_type][slot_role]
sbs.vars[slot_var_id]['steps_slots'].add((step_type, slot_role))
new_slot = Slot.from_var(slot_role_id, slot_id, slot_name, slot_ont_types, slot_var_id,
sbs.vars[slot_var_id])
step_slots.append(new_slot)
return Step(step_type_id, step_id, step_name, step_comment, step_slots)
def xpath(query: str, root: lxml.etree.Element) -> List[lxml.etree.Element]:
return root.xpath(query, namespaces=nsmap)
def parse_middle(self, e: lxml.etree.Element):
assert e.tag == "middle"
yield "--- middle\n"
for c in e.getchildren():
yield from self.parse(c)