Download omnilmm/lib/python3.10/site-packages/lxml/objectpath.pxi from ZTWHHH/envs_2: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/datasets/ZTWHHH/envs_2/resolve/main/omnilmm/lib/python3.10/site-packages/lxml/objectpath.pxi
- Command line
-
hf download hf://datasets/ZTWHHH/envs_2/omnilmm/lib/python3.10/site-packages/lxml/objectpath.pxi
-
curl -L -o objectpath.pxi https://huggingface.co/datasets/ZTWHHH/envs_2/resolve/main/omnilmm/lib/python3.10/site-packages/lxml/objectpath.pxi
11.5 kB
| ################################################################################ | |
| # ObjectPath | |
| ctypedef struct _ObjectPath: | |
| const_xmlChar* href | |
| const_xmlChar* name | |
| Py_ssize_t index | |
| cdef object _NO_DEFAULT = object() | |
| cdef class ObjectPath: | |
| """ObjectPath(path) | |
| Immutable object that represents a compiled object path. | |
| Example for a path: 'root.child[1].{other}child[25]' | |
| """ | |
| cdef readonly object find | |
| cdef list _path | |
| cdef object _path_str | |
| cdef _ObjectPath* _c_path | |
| cdef Py_ssize_t _path_len | |
| def __init__(self, path): | |
| if python._isString(path): | |
| self._path = _parse_object_path_string(path) | |
| self._path_str = path | |
| else: | |
| self._path = _parse_object_path_list(path) | |
| self._path_str = '.'.join(path) | |
| self._path_len = len(self._path) | |
| self._c_path = _build_object_path_segments(self._path) | |
| self.find = self.__call__ | |
| def __dealloc__(self): | |
| if self._c_path is not NULL: | |
| python.lxml_free(self._c_path) | |
| def __str__(self): | |
| return self._path_str | |
| def __call__(self, _Element root not None, *_default): | |
| """Follow the attribute path in the object structure and return the | |
| target attribute value. | |
| If it it not found, either returns a default value (if one was passed | |
| as second argument) or raises AttributeError. | |
| """ | |
| if _default: | |
| if len(_default) > 1: | |
| raise TypeError, "invalid number of arguments: needs one or two" | |
| default = _default[0] | |
| else: | |
| default = _NO_DEFAULT | |
| return _find_object_path(root, self._c_path, self._path_len, default) | |
| def hasattr(self, _Element root not None): | |
| "hasattr(self, root)" | |
| try: | |
| _find_object_path(root, self._c_path, self._path_len, _NO_DEFAULT) | |
| except AttributeError: | |
| return False | |
| return True | |
| def setattr(self, _Element root not None, value): | |
| """setattr(self, root, value) | |
| Set the value of the target element in a subtree. | |
| If any of the children on the path does not exist, it is created. | |
| """ | |
| _create_object_path(root, self._c_path, self._path_len, 1, value) | |
| def addattr(self, _Element root not None, value): | |
| """addattr(self, root, value) | |
| Append a value to the target element in a subtree. | |
| If any of the children on the path does not exist, it is created. | |
| """ | |
| _create_object_path(root, self._c_path, self._path_len, 0, value) | |
| cdef object __MATCH_PATH_SEGMENT = re.compile( | |
| r"(\.?)\s*(?:\{([^}]*)\})?\s*([^.{}\[\]\s]+)\s*(?:\[\s*([-0-9]+)\s*\])?", | |
| re.U).match | |
| cdef tuple _RELATIVE_PATH_SEGMENT = (None, None, 0) | |
| cdef list _parse_object_path_string(_path): | |
| """Parse object path string into a (ns, name, index) list. | |
| """ | |
| cdef bint has_dot | |
| cdef unicode path | |
| new_path = [] | |
| if isinstance(_path, bytes): | |
| path = (<bytes>_path).decode('ascii') | |
| elif type(_path) is not unicode: | |
| path = unicode(_path) | |
| else: | |
| path = _path | |
| path = path.strip() | |
| if path == '.': | |
| return [_RELATIVE_PATH_SEGMENT] | |
| path_pos = 0 | |
| while path: | |
| match = __MATCH_PATH_SEGMENT(path, path_pos) | |
| if match is None: | |
| break | |
| dot, ns, name, index = match.groups() | |
| index = int(index) if index else 0 | |
| has_dot = dot == '.' | |
| if not new_path: | |
| if has_dot: | |
| # path '.child' => ignore root | |
| new_path.append(_RELATIVE_PATH_SEGMENT) | |
| elif index: | |
| raise ValueError, "index not allowed on root node" | |
| elif not has_dot: | |
| raise ValueError, "invalid path" | |
| if ns is not None: | |
| ns = python.PyUnicode_AsUTF8String(ns) | |
| name = python.PyUnicode_AsUTF8String(name) | |
| new_path.append( (ns, name, index) ) | |
| path_pos = match.end() | |
| if not new_path or len(path) > path_pos: | |
| raise ValueError, "invalid path" | |
| return new_path | |
| cdef list _parse_object_path_list(path): | |
| """Parse object path sequence into a (ns, name, index) list. | |
| """ | |
| new_path = [] | |
| for item in path: | |
| item = item.strip() | |
| if not new_path and item == '': | |
| # path '.child' => ignore root | |
| ns = name = None | |
| index = 0 | |
| else: | |
| ns, name = cetree.getNsTag(item) | |
| c_name = _xcstr(name) | |
| index_pos = tree.xmlStrchr(c_name, c'[') | |
| if index_pos is NULL: | |
| index = 0 | |
| else: | |
| index_end = tree.xmlStrchr(index_pos + 1, c']') | |
| if index_end is NULL: | |
| raise ValueError, "index must be enclosed in []" | |
| index = int(index_pos[1:index_end - index_pos]) | |
| if not new_path and index != 0: | |
| raise ValueError, "index not allowed on root node" | |
| name = <bytes>c_name[:index_pos - c_name] | |
| new_path.append( (ns, name, index) ) | |
| if not new_path: | |
| raise ValueError, "invalid path" | |
| return new_path | |
| cdef _ObjectPath* _build_object_path_segments(list path_list) except NULL: | |
| cdef _ObjectPath* c_path | |
| cdef _ObjectPath* c_path_segments | |
| c_path_segments = <_ObjectPath*>python.lxml_malloc(len(path_list), sizeof(_ObjectPath)) | |
| if c_path_segments is NULL: | |
| raise MemoryError() | |
| c_path = c_path_segments | |
| for href, name, index in path_list: | |
| c_path[0].href = _xcstr(href) if href is not None else NULL | |
| c_path[0].name = _xcstr(name) if name is not None else NULL | |
| c_path[0].index = index | |
| c_path += 1 | |
| return c_path_segments | |
| cdef _find_object_path(_Element root, _ObjectPath* c_path, Py_ssize_t c_path_len, default_value): | |
| """Follow the path to find the target element. | |
| """ | |
| cdef tree.xmlNode* c_node | |
| cdef Py_ssize_t c_index | |
| c_node = root._c_node | |
| c_name = c_path[0].name | |
| c_href = c_path[0].href | |
| if c_href is NULL or c_href[0] == c'\0': | |
| c_href = tree._getNs(c_node) | |
| if not cetree.tagMatches(c_node, c_href, c_name): | |
| if default_value is not _NO_DEFAULT: | |
| return default_value | |
| else: | |
| raise ValueError( | |
| f"root element does not match: need {cetree.namespacedNameFromNsName(c_href, c_name)}, got {root.tag}") | |
| while c_node is not NULL: | |
| c_path_len -= 1 | |
| if c_path_len <= 0: | |
| break | |
| c_path += 1 | |
| if c_path[0].href is not NULL: | |
| c_href = c_path[0].href # otherwise: keep parent namespace | |
| c_name = tree.xmlDictExists(c_node.doc.dict, c_path[0].name, -1) | |
| if c_name is NULL: | |
| c_name = c_path[0].name | |
| c_node = NULL | |
| break | |
| c_index = c_path[0].index | |
| c_node = c_node.last if c_index < 0 else c_node.children | |
| c_node = _findFollowingSibling(c_node, c_href, c_name, c_index) | |
| if c_node is not NULL: | |
| return cetree.elementFactory(root._doc, c_node) | |
| elif default_value is not _NO_DEFAULT: | |
| return default_value | |
| else: | |
| tag = cetree.namespacedNameFromNsName(c_href, c_name) | |
| raise AttributeError, f"no such child: {tag}" | |
| cdef _create_object_path(_Element root, _ObjectPath* c_path, | |
| Py_ssize_t c_path_len, int replace, value): | |
| """Follow the path to find the target element, build the missing children | |
| as needed and set the target element to 'value'. If replace is true, an | |
| existing value is replaced, otherwise the new value is added. | |
| """ | |
| cdef _Element child | |
| cdef tree.xmlNode* c_node | |
| cdef tree.xmlNode* c_child | |
| cdef Py_ssize_t c_index | |
| if c_path_len == 1: | |
| raise TypeError, "cannot update root node" | |
| c_node = root._c_node | |
| c_name = c_path[0].name | |
| c_href = c_path[0].href | |
| if c_href is NULL or c_href[0] == c'\0': | |
| c_href = tree._getNs(c_node) | |
| if not cetree.tagMatches(c_node, c_href, c_name): | |
| raise ValueError( | |
| f"root element does not match: need {cetree.namespacedNameFromNsName(c_href, c_name)}, got {root.tag}") | |
| while c_path_len > 1: | |
| c_path_len -= 1 | |
| c_path += 1 | |
| if c_path[0].href is not NULL: | |
| c_href = c_path[0].href # otherwise: keep parent namespace | |
| c_index = c_path[0].index | |
| c_name = tree.xmlDictExists(c_node.doc.dict, c_path[0].name, -1) | |
| if c_name is NULL: | |
| c_name = c_path[0].name | |
| c_child = NULL | |
| else: | |
| c_child = c_node.last if c_index < 0 else c_node.children | |
| c_child = _findFollowingSibling(c_child, c_href, c_name, c_index) | |
| if c_child is not NULL: | |
| c_node = c_child | |
| elif c_index != 0: | |
| raise TypeError, "creating indexed path attributes is not supported" | |
| elif c_path_len == 1: | |
| _appendValue(cetree.elementFactory(root._doc, c_node), | |
| cetree.namespacedNameFromNsName(c_href, c_name), | |
| value) | |
| return | |
| else: | |
| child = cetree.makeSubElement( | |
| cetree.elementFactory(root._doc, c_node), | |
| cetree.namespacedNameFromNsName(c_href, c_name), | |
| None, None, None, None) | |
| c_node = child._c_node | |
| # if we get here, the entire path was already there | |
| if replace: | |
| element = cetree.elementFactory(root._doc, c_node) | |
| _replaceElement(element, value) | |
| else: | |
| _appendValue(cetree.elementFactory(root._doc, c_node.parent), | |
| cetree.namespacedName(c_node), value) | |
| cdef list _build_descendant_paths(tree.xmlNode* c_node, prefix_string): | |
| """Returns a list of all descendant paths. | |
| """ | |
| cdef list path, path_list | |
| tag = cetree.namespacedName(c_node) | |
| if prefix_string: | |
| if prefix_string[-1] != '.': | |
| prefix_string += '.' | |
| prefix_string = prefix_string + tag | |
| else: | |
| prefix_string = tag | |
| path = [prefix_string] | |
| path_list = [] | |
| _recursive_build_descendant_paths(c_node, path, path_list) | |
| return path_list | |
| cdef int _recursive_build_descendant_paths(tree.xmlNode* c_node, | |
| list path, list path_list) except -1: | |
| """Fills the list 'path_list' with all descendant paths, initial prefix | |
| being in the list 'path'. | |
| """ | |
| cdef tree.xmlNode* c_child | |
| tags = {} | |
| path_list.append('.'.join(path)) | |
| c_href = tree._getNs(c_node) | |
| c_child = c_node.children | |
| while c_child is not NULL: | |
| while c_child.type != tree.XML_ELEMENT_NODE: | |
| c_child = c_child.next | |
| if c_child is NULL: | |
| return 0 | |
| if c_href is tree._getNs(c_child): | |
| tag = pyunicode(c_child.name) | |
| elif c_href is not NULL and tree._getNs(c_child) is NULL: | |
| # special case: parent has namespace, child does not | |
| tag = '{}' + pyunicode(c_child.name) | |
| else: | |
| tag = cetree.namespacedName(c_child) | |
| count = tags.get(tag) | |
| if count is None: | |
| tags[tag] = 1 | |
| else: | |
| tags[tag] = count + 1 | |
| tag += f'[{count}]' | |
| path.append(tag) | |
| _recursive_build_descendant_paths(c_child, path, path_list) | |
| del path[-1] | |
| c_child = c_child.next | |
| return 0 | |