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"] ])