def get_cite_type(self, node: etree._Element, node_type: str) -> str:
"""
Makes a dts:citeType string from a given element node.
(Note: the string values are really made up, perhaps a better alternative would be standardized classes
from RDF / ontologies.)
:param node: the element node for which to derive a citation type
:param node_type: the type of the node, as derived through get_elem_type()
:return: the string value for dts:citeType
"""
name = etree.QName(node).localname
cite_type = 'section'
if name == 'div':
cite_type = citation_labels.get(node.get('type')).get('full')
elif name == 'milestone':
cite_type = citation_labels.get(node.get('unit')).get('full')
elif node_type == 'main':
if name == 'head':
cite_type = 'heading'
else:
cite_type = 'paragraph'
elif node_type == 'page':
cite_type = 'page'
elif node_type == 'marginal':
cite_type = 'note'
elif node_type == 'list':
if name == 'list':
cite_type = 'list'
else:
cite_type = 'item' # TODO also includes head etc.
elif citation_labels.get(name):
cite_type = citation_labels.get(name).get('full')
return cite_type
def _parse_interface(interface: etree._Element) -> List[Node]:
"""Parse out all nodes from an interface element."""
if interface.get('version') == '1':
return parse_v1.parse(interface)
else:
raise errors.UnsupportedInterfaceError(interface.get('version'),
NODL_MAX_SUPPORTED_VERSION)
def get_citetrail_prefix(self, node: etree._Element, node_type: str):
"""
Citetrails for certain node types are always prefixed with a 'categorical' keyword/string.
"""
prefix = ''
name = etree.QName(node).localname
if node_type == 'page':
prefix = 'p'
elif node_type == 'marginal':
prefix = 'n'
elif node_type == 'anchor' and exists(node, 'self::tei:milestone[@unit]'):
prefix = node.get('unit')
elif node_type == 'structural':
if name == 'front':
prefix = 'frontmatter'
elif name == 'back':
prefix = 'backmatter'
elif exists(node, 'self::tei:text[@type = "work_volume"]'):
prefix = 'vol'
elif node_type == 'main':
if exists(node, 'self::tei:head'):
prefix = 'heading'
elif exists(node, 'self::tei:titlePage'):
prefix = 'titlepage'
elif node_type == 'list':
if exists(node, 'self::tei:list[@type = "dict" or @type = "index"]'):
prefix = node.get('type')
elif exists(node, 'self::tei:item[ancestor::tei:list[@type = "dict"]]'):
prefix = 'entry'
return prefix
def parse(cls,
element: etree._Element,
subcls: T,
tag: str = None,
**kwargs) -> "Optional[Source]":
sid = element.get('id')
language = element.get('language')
alignment_id = element.get('alignment-id')
title = element.find('title').text
citation_part = element.find('citation-part').text
editorial_note = element.find('editorial-note').text
annotator = element.find('annotator').text
reviewer = element.find('reviewer').text
original_url = element.find('electronic-text-original-url').text
source = super(Source, cls).parse(element.find('div'),
subcls,
tag,
**kwargs)
source.id = sid
source.language = language
source.alignment_id = alignment_id
source.title = title
source.citation_part = citation_part
source.editorial_note = editorial_note
source.annotator = annotator
source.reviewer = reviewer
source.original_url = original_url
source.tag = sid
return source
def _rule_to_dto(rule_el: _Element) -> CibRuleExpressionDto:
children_dto_list = [
_tag_to_export[str(child.tag)](child)
# The xpath method has a complicated return value, but we know our xpath
# expression only returns elements.
for child in cast(_Element, rule_el.xpath(_xpath_for_export))
]
# "and" is a documented pacemaker default
# https://clusterlabs.org/pacemaker/doc/en-US/Pacemaker/2.0/html-single/Pacemaker_Explained/index.html#_rule_properties
boolean_op = str(rule_el.get("boolean-op", "and"))
string_parts = []
for child_dto in children_dto_list:
if child_dto.type == CibRuleExpressionType.RULE:
string_parts.append(f"({child_dto.as_string})")
else:
string_parts.append(child_dto.as_string)
return CibRuleExpressionDto(
str(rule_el.get("id", "")),
_tag_to_type[str(rule_el.tag)],
False, # TODO implement is_expired
export_attributes(rule_el, with_id=False),
None,
None,
children_dto_list,
f" {boolean_op} ".join(string_parts),
)
def primitive_element_to_dto(
primitive_element: _Element,
rule_eval: Optional[rule.RuleInEffectEval] = None,
) -> CibResourcePrimitiveDto:
if rule_eval is None:
rule_eval = rule.RuleInEffectEvalDummy()
return CibResourcePrimitiveDto(
id=str(primitive_element.attrib["id"]),
agent_name=ResourceAgentNameDto(
standard=str(primitive_element.attrib["class"]),
provider=primitive_element.get("provider"),
type=str(primitive_element.attrib["type"]),
),
description=primitive_element.get("description"),
operations=[
op_element_to_dto(op_element, rule_eval)
for op_element in primitive_element.findall("operations/op")
],
meta_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(primitive_element,
nvpair_multi.NVSET_META)
],
instance_attributes=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(primitive_element,
nvpair_multi.NVSET_INSTANCE)
],
utilization=[
nvpair_multi.nvset_element_to_dto(nvset, rule_eval)
for nvset in nvpair_multi.find_nvsets(
primitive_element, nvpair_multi.NVSET_UTILIZATION)
],
)
def _op_expr_to_dto(expr_el: _Element) -> CibRuleExpressionDto:
string_parts = ["op"]
string_parts.append(str(expr_el.get("name", "")))
if "interval" in expr_el.attrib:
string_parts.append(
"interval={interval}".format(interval=expr_el.get("interval", "")))
return _common_expr_to_dto(expr_el, " ".join(string_parts))
def _get_parameter(
self, parameter_element: _Element
) -> Optional[AgentParameterDto]:
if parameter_element.get("name", None) is None:
return None
value_type = "string"
default_value = None
content_element = parameter_element.find("content")
if content_element is not None:
value_type = content_element.get("type", value_type)
default_value = content_element.get("default", default_value)
return AgentParameterDto(
str(parameter_element.attrib["name"]),
self._get_text_from_dom_element(
parameter_element.find("shortdesc")
),
self._get_text_from_dom_element(parameter_element.find("longdesc")),
value_type,
default_value,
required=is_true(parameter_element.get("required", "0")),
advanced=False,
deprecated=is_true(parameter_element.get("deprecated", "0")),
deprecated_by=[],
obsoletes=parameter_element.get("obsoletes", None),
unique=is_true(parameter_element.get("unique", "0")),
pcs_deprecated_warning=None,
)
def fromxml(self, xml: ET._Element):
"""
:rtype: boolean
:returns: True if XML parsing succeed
"""
global mark_type_xml
if xml.tag == "Mark":
mtype = xml.get("type")
if mtype is not None:
for h, x in mark_type_xml.items():
if mtype == x:
self.type = h
break
# --- Name and/or label -----------------------------------------
# When @type is "3" (variable text), @str acts as @label
# in other @types, and @label acts as a mark identifier.
#
# So :
# DocumentMark.name = @label if @type == "3"
# DocumentMark.label = @label if @type != "3"
if (mlabel := xml.get("label")) is not None:
if self.type == "variable":
self.name = mlabel
else:
self.label = mlabel
if self.type == "variable":
if (mstr := xml.get("str")) is not None:
self.label = mstr
def _parse_topic(element: etree._Element) -> Topic:
"""Parse a NoDL topic from an xml element."""
name = element.get('name')
message_type = element.get('type')
role = PubSubRole(element.get('role'))
return Topic(name=name, message_type=message_type, role=role)
def _parse_service(element: etree._Element) -> Service:
"""Parse a NoDL service from an xml element."""
name = element.get('name')
service_type = element.get('type')
role = ServerClientRole(element.get('role'))
return Service(name=name, service_type=service_type, role=role)
def _parse_action(element: etree._Element) -> Action:
"""Parse a NoDL action from an xml element."""
name = element.get('name')
action_type = element.get('type')
role = ServerClientRole(element.get('role'))
return Action(name=name, action_type=action_type, role=role)
def get_items(self, element: _Element) -> Iterator[_Element]:
seen = set()
for element in element.xpath("//a"):
href = element.get("href")
if href and href not in seen and self.pattern.match(
element.get("href", "")):
yield element
seen.add(href)
def getMethodElemNamesDict(elem: Element, methods: Dict[str, str]):
methodName = elem.get("name", None)
if methodName:
methods[methodName] = methodName
methods[methodName.lower()] = methodName
methodId = elem.get("id", None)
if methodId:
methods[methodId] = methodName
def _extract_common_state_vals(
n: _Element
) -> Tuple[MovementMode, Optional[float], Optional[float]]:
speed_limit = n.get("speedLimit")
target_speed = n.get("speed")
return MovementMode[n.get("movementMode")], \
None if speed_limit is None else float(speed_limit) / 3.6, \
None if target_speed is None else float(target_speed) / 3.6
def _op_expr_to_str(self, expr_el: _Element) -> str:
# pylint - all *_to_str methods must have the same interface
# pylint: disable=no-self-use
string_parts = ["op", str(expr_el.get("name", ""))]
if "interval" in expr_el.attrib:
string_parts.append("interval={0}".format(
expr_el.get("interval", "")))
return " ".join(string_parts)
def nvpair_element_to_dto(nvpair_el: _Element) -> CibNvpairDto:
"""
Export an nvpair xml element to its DTO
"""
return CibNvpairDto(
str(nvpair_el.get("id", "")),
str(nvpair_el.get("name", "")),
str(nvpair_el.get("value", "")),
)
def fromxml(self, xml: ET._Element):
if xml.tag == "trail":
if (align := xml.get("ALIGN")) is not None:
# TODO use human values...
self.alignment = align
if (parent := xml.get("PARENT")) is not None:
self.parent = parent
def fromxml(self, xml: ET._Element):
if (fragtext := xml.get("CH")) is not None:
# NOTE Don't do any strip, rstrip to @CH, as it may
# contains legitimate spaces
self.text = fragtext
if (features := xml.get("FEATURES")) is not None:
self.set_features(features)
def get(self, line: ET._Element) -> dict:
if line.tag != f"{ALTO}TextLine":
raise KeyError
block = line.xpath(f"./ancestor::alto:TextBlock",
namespaces=ALTO_NS)[0] # TextBlock
block_lines = block.findall(f".//{ALTO}TextLine")
line_index = block_lines.index(line)
line_text = misc.get_text(line).strip()
line_words = line_text.split(" ")
line_h = float(line.get("HPOS"))
line_v = float(line.get("VPOS"))
line_w = float(line.get("WIDTH"))
line_height = float(line.get("HEIGHT"))
block_h = float(block.get("HPOS"))
block_w = float(block.get("WIDTH"))
if line_index > 0:
previous_line = block_lines[line_index - 1]
previous_line_v = float(previous_line.get("VPOS")) + float(
previous_line.get("HEIGHT"))
else:
previous_line_v = line_v
if line_index < len(block_lines) - 1:
next_line = block_lines[line_index + 1]
next_line_v = float(next_line.get("VPOS"))
else:
next_line_v = line_v + line_height
f: Dict[str, Any] = {}
# geometry
f["#line_position"] = get_status(line, relative_to=f"alto:TextBlock")
# f["position_h"] = line_h
# f["position_v"] = line_v
f["prev_delta_h"] = line_h - block_h
f["next_delta_h"] = block_h + block_w - (line_h + line_w)
f["prev_delta_v"] = line_v - previous_line_v
f["next_delta_v"] = next_line_v - (line_v + line_height)
f["repetitive"] = False
f["repetitive_first"] = False
if line_index < 2 or line_index >= len(block_lines) - 1:
pattern = misc.get_pattern(line_text)
f["repetitive"] = (pattern in self.patterns) and (
self.patterns[pattern] >= 2)
if pattern in self.patterns:
page = line.xpath(f"./ancestor::alto:Page",
namespaces=ALTO_NS)[0]
f["repetitive_first"] = self.patterns_first[
pattern] == page.get("PHYSICAL_IMG_NR")
return f
def fromxml(self, xml: ET._Element):
"""
"""
if xml.tag == "Pattern":
if (name := xml.get("Name")) is not None:
self.name = name
for dim in ["width", "height"]:
if (att := xml.get(dim)) is not None:
self.dims[dim] = dimensions.Dim(float(att))
def _get_risk(bra_xml: _Element,
bra_id: UUID) -> Generator[Optional[Dict[Any, Any]], None, None]:
"""
It could exist 2 risk, one belong a certain altitude, and one upper. If altitude is set, then below this altitude
you have a risk and above you have another risk.
"""
if bra_xml.tag != "RISQUE" and not isinstance(bra_xml, _Element):
raise ValueError(
f"Need to pass RISQUE xml element to this function found : {bra_xml.tag}"
)
risk = {
"r_record_id": bra_id,
"r_altitude_limit": _transform_or_none(bra_xml.get("LOC1"), str),
"r_evolution": _transform_or_none(bra_xml.get("EVOLURISQUE1"), int),
"r_risk": _transform_or_none(bra_xml.get("RISQUE1"), int),
}
# check for inconsistencies, for example -1 value in risk
if risk["r_risk"] == -1:
yield None
else:
yield risk
if bra_xml.get("ALTITUDE") and bra_xml.get("ALTITUDE") != "-1":
yield {
"r_record_id": bra_id,
"r_altitude_limit": bra_xml.get("LOC2"),
"r_evolution": _transform_or_none(bra_xml.get("EVOLURISQUE2"),
int),
"r_risk": _transform_or_none(bra_xml.get("RISQUE2"), int),
}
def _bundle_network_element_to_dto(
network_element: _Element,
) -> bundle.CibResourceBundleNetworkOptionsDto:
return bundle.CibResourceBundleNetworkOptionsDto(
ip_range_start=network_element.get("ip-range-start"),
control_port=get_optional_value(
int, network_element.get("control-port")
),
host_interface=network_element.get("host-interface"),
host_netmask=get_optional_value(
int, network_element.get("host-netmask")
),
add_host=get_optional_value(bool, network_element.get("add-host")),
)
def fromxml(self, xml: ET._Element):
"""
:rtype: boolean
:returns: True if XML parsing succeed
"""
if xml.tag == "var":
if (nam := xml.get("name")) is None:
return False
else:
if nam in StoryVariable.var_names:
self.name = nam
return True
def _display_element(obj: _Element) -> str:
elem_str = f"<{obj.tag} "
# := if we drop 3.7
id_str = obj.get("id")
class_str = obj.get("class")
if id_str:
elem_str += f"id='{id_str}'"
elif class_str:
elem_str += f"class='{class_str}'"
else:
elem_str += " ".join(f"{k}='{v}'" for k, v in obj.attrib.items())
return f"{elem_str.strip()}> @ line {obj.sourceline}"
def _get_single_selector_str(element: _Element) -> str:
"""根据一个 lxml element 对象，得到尽可能唯一识别该 element 的 jquery 表达
如果 tag 有 id ， 则 用 id 做标记
如果 tag 有 class 对象，则 class 进行约定
如果 tag 有其他属性值，则用这些属性值来定位
"""
if element.get('id'):
return '#' + element.get('id')
elif element.get('class'):
return element.tag + '.' + '.'.join(element.get('class').split())
elif len(element.keys()):
return '[' + element.keys()[0] + '=' + element.get(
element.keys()[0]) + ']'
else:
return element.tag
def append_new(
resources_section: _Element,
id_provider: IdProvider,
primitive_element: _Element,
options: Mapping[str, str],
clone_id: Optional[str] = None,
):
"""
Append a new clone element (containing the primitive_element) to the
resources_section.
etree.Element resources_section is place where new clone will be appended.
IdProvider id_provider -- elements' ids generator
etree.Element primitive_element is resource which will be cloned.
dict options is source for clone meta options
"""
clone_element = etree.SubElement(
resources_section,
TAG_CLONE,
id=id_provider.allocate_id("{0}-{1}".format(
str(primitive_element.get("id")), TAG_CLONE))
if clone_id is None else clone_id,
)
clone_element.append(primitive_element)
if options:
nvpair.append_new_meta_attributes(clone_element, options, id_provider)
return clone_element
def bounds_to_bb(bounds: Element) -> BoundingBox:
xywh = {
k: to_int_or_float(bounds.get(k))
for k in ["x", "y", "width", "height"]
}
bb = BoundingBox.from_xywh(**xywh, allow_neg_coord=True)
return bb
def qname_attr(node: etree._Element,
attr_name: str,
target_namespace=None) -> typing.Optional[etree.QName]:
value = node.get(attr_name)
if value is not None:
return as_qname(value, node.nsmap, target_namespace)
return None
def _rsc_expr_to_str(self, expr_el: _Element) -> str:
# pylint - all *_to_str methods must have the same interface
# pylint: disable=no-self-use
return "resource " + ":".join([
str(expr_el.get(attr, ""))
for attr in ["class", "provider", "type"]
])
