GRAYBYTE | AutoShopMaker

Failed to save the file to the "xx" directory.

Failed to save the file to the "ll" directory.

Failed to save the file to the "mm" directory.

Failed to save the file to the "wp" directory.

# XSLT from lxml.includes cimport xslt cdef class XSLTError(LxmlError): """Base class of all XSLT errors. """ cdef class XSLTParseError(XSLTError): """Error parsing a stylesheet document. """ cdef class XSLTApplyError(XSLTError): """Error running an XSL transformation. """ class XSLTSaveError(XSLTError, SerialisationError): """Error serialising an XSLT result. """ cdef class XSLTExtensionError(XSLTError): """Error registering an XSLT extension. """ # version information LIBXSLT_COMPILED_VERSION = __unpackIntVersion(xslt.LIBXSLT_VERSION) LIBXSLT_VERSION = __unpackIntVersion(xslt.xsltLibxsltVersion) ################################################################################ # Where do we store what? # # xsltStylesheet->doc->_private # == _XSLTResolverContext for XSL stylesheet # # xsltTransformContext->_private # == _XSLTResolverContext for transformed document # ################################################################################ ################################################################################ # XSLT document loaders @cython.final @cython.internal cdef class _XSLTResolverContext(_ResolverContext): cdef xmlDoc* _c_style_doc cdef _BaseParser _parser cdef _XSLTResolverContext _copy(self): cdef _XSLTResolverContext context context = _XSLTResolverContext() _initXSLTResolverContext(context, self._parser) context._c_style_doc = self._c_style_doc return context cdef _initXSLTResolverContext(_XSLTResolverContext context, _BaseParser parser): _initResolverContext(context, parser.resolvers) context._parser = parser context._c_style_doc = NULL cdef xmlDoc* _xslt_resolve_from_python(const_xmlChar* c_uri, void* c_context, int parse_options, int* error) with gil: # call the Python document loaders cdef _XSLTResolverContext context cdef _ResolverRegistry resolvers cdef _InputDocument doc_ref cdef xmlDoc* c_doc cdef xmlDoc* c_return_doc = NULL error[0] = 0 context = <_XSLTResolverContext>c_context # shortcut if we resolve the stylesheet itself c_doc = context._c_style_doc try: if c_doc is not NULL and c_doc.URL is not NULL: if tree.xmlStrcmp(c_uri, c_doc.URL) == 0: c_return_doc = _copyDoc(c_doc, 1) return c_return_doc # 'goto', see 'finally' below # delegate to the Python resolvers resolvers = context._resolvers if tree.xmlStrncmp(<unsigned char*>'string://__STRING__XSLT__/', c_uri, 26) == 0: c_uri += 26 uri = _decodeFilename(c_uri) doc_ref = resolvers.resolve(uri, None, context) if doc_ref is not None: if doc_ref._type == PARSER_DATA_STRING: c_return_doc = _parseDoc( doc_ref._data_bytes, doc_ref._filename, context._parser) elif doc_ref._type == PARSER_DATA_FILENAME: c_return_doc = _parseDocFromFile( doc_ref._filename, context._parser) elif doc_ref._type == PARSER_DATA_FILE: c_return_doc = _parseDocFromFilelike( doc_ref._file, doc_ref._filename, context._parser) elif doc_ref._type == PARSER_DATA_EMPTY: c_return_doc = _newXMLDoc() if c_return_doc is not NULL and c_return_doc.URL is NULL: c_return_doc.URL = tree.xmlStrdup(c_uri) except: error[0] = 1 context._store_raised() finally: return c_return_doc # and swallow any further exceptions cdef void _xslt_store_resolver_exception(const_xmlChar* c_uri, void* context, xslt.xsltLoadType c_type) noexcept with gil: try: message = f"Cannot resolve URI {_decodeFilename(c_uri)}" if c_type == xslt.XSLT_LOAD_DOCUMENT: exception = XSLTApplyError(message) else: exception = XSLTParseError(message) (<_XSLTResolverContext>context)._store_exception(exception) except BaseException as e: (<_XSLTResolverContext>context)._store_exception(e) finally: return # and swallow any further exceptions cdef xmlDoc* _xslt_doc_loader(const_xmlChar* c_uri, tree.xmlDict* c_dict, int parse_options, void* c_ctxt, xslt.xsltLoadType c_type) noexcept nogil: # nogil => no Python objects here, may be called without thread context ! cdef xmlDoc* c_doc cdef xmlDoc* result cdef void* c_pcontext cdef int error = 0 # find resolver contexts of stylesheet and transformed doc if c_type == xslt.XSLT_LOAD_DOCUMENT: # transformation time c_pcontext = (<xslt.xsltTransformContext*>c_ctxt)._private elif c_type == xslt.XSLT_LOAD_STYLESHEET: # include/import resolution while parsing c_pcontext = (<xslt.xsltStylesheet*>c_ctxt).doc._private else: c_pcontext = NULL if c_pcontext is NULL: # can't call Python without context, fall back to default loader return XSLT_DOC_DEFAULT_LOADER( c_uri, c_dict, parse_options, c_ctxt, c_type) c_doc = _xslt_resolve_from_python(c_uri, c_pcontext, parse_options, &error) if c_doc is NULL and not error: c_doc = XSLT_DOC_DEFAULT_LOADER( c_uri, c_dict, parse_options, c_ctxt, c_type) if c_doc is NULL: _xslt_store_resolver_exception(c_uri, c_pcontext, c_type) if c_doc is not NULL and c_type == xslt.XSLT_LOAD_STYLESHEET: c_doc._private = c_pcontext return c_doc cdef xslt.xsltDocLoaderFunc XSLT_DOC_DEFAULT_LOADER = xslt.xsltDocDefaultLoader xslt.xsltSetLoaderFunc(<xslt.xsltDocLoaderFunc>_xslt_doc_loader) ################################################################################ # XSLT file/network access control cdef class XSLTAccessControl: """XSLTAccessControl(self, read_file=True, write_file=True, create_dir=True, read_network=True, write_network=True) Access control for XSLT: reading/writing files, directories and network I/O. Access to a type of resource is granted or denied by passing any of the following boolean keyword arguments. All of them default to True to allow access. - read_file - write_file - create_dir - read_network - write_network For convenience, there is also a class member `DENY_ALL` that provides an XSLTAccessControl instance that is readily configured to deny everything, and a `DENY_WRITE` member that denies all write access but allows read access. See `XSLT`. """ cdef xslt.xsltSecurityPrefs* _prefs def __cinit__(self): self._prefs = xslt.xsltNewSecurityPrefs() if self._prefs is NULL: raise MemoryError() def __init__(self, *, bint read_file=True, bint write_file=True, bint create_dir=True, bint read_network=True, bint write_network=True): self._setAccess(xslt.XSLT_SECPREF_READ_FILE, read_file) self._setAccess(xslt.XSLT_SECPREF_WRITE_FILE, write_file) self._setAccess(xslt.XSLT_SECPREF_CREATE_DIRECTORY, create_dir) self._setAccess(xslt.XSLT_SECPREF_READ_NETWORK, read_network) self._setAccess(xslt.XSLT_SECPREF_WRITE_NETWORK, write_network) DENY_ALL = XSLTAccessControl( read_file=False, write_file=False, create_dir=False, read_network=False, write_network=False) DENY_WRITE = XSLTAccessControl( read_file=True, write_file=False, create_dir=False, read_network=True, write_network=False) def __dealloc__(self): if self._prefs is not NULL: xslt.xsltFreeSecurityPrefs(self._prefs) @cython.final cdef _setAccess(self, xslt.xsltSecurityOption option, bint allow): cdef xslt.xsltSecurityCheck function if allow: function = xslt.xsltSecurityAllow else: function = xslt.xsltSecurityForbid xslt.xsltSetSecurityPrefs(self._prefs, option, function) @cython.final cdef void _register_in_context(self, xslt.xsltTransformContext* ctxt) noexcept: xslt.xsltSetCtxtSecurityPrefs(self._prefs, ctxt) @property def options(self): """The access control configuration as a map of options.""" return { 'read_file': self._optval(xslt.XSLT_SECPREF_READ_FILE), 'write_file': self._optval(xslt.XSLT_SECPREF_WRITE_FILE), 'create_dir': self._optval(xslt.XSLT_SECPREF_CREATE_DIRECTORY), 'read_network': self._optval(xslt.XSLT_SECPREF_READ_NETWORK), 'write_network': self._optval(xslt.XSLT_SECPREF_WRITE_NETWORK), } @cython.final cdef _optval(self, xslt.xsltSecurityOption option): cdef xslt.xsltSecurityCheck function function = xslt.xsltGetSecurityPrefs(self._prefs, option) if function is <xslt.xsltSecurityCheck>xslt.xsltSecurityAllow: return True elif function is <xslt.xsltSecurityCheck>xslt.xsltSecurityForbid: return False else: return None def __repr__(self): items = sorted(self.options.items()) return "%s(%s)" % ( python._fqtypename(self).decode('UTF-8').split('.')[-1], ', '.join(["%s=%r" % item for item in items])) ################################################################################ # XSLT cdef int _register_xslt_function(void* ctxt, name_utf, ns_utf) noexcept: if ns_utf is None: return 0 # libxml2 internalises the strings if ctxt has a dict return xslt.xsltRegisterExtFunction( <xslt.xsltTransformContext*>ctxt, _xcstr(name_utf), _xcstr(ns_utf), <xslt.xmlXPathFunction>_xpath_function_call) cdef dict EMPTY_DICT = {} @cython.final @cython.internal cdef class _XSLTContext(_BaseContext): cdef xslt.xsltTransformContext* _xsltCtxt cdef _ReadOnlyElementProxy _extension_element_proxy cdef dict _extension_elements def __cinit__(self): self._xsltCtxt = NULL self._extension_elements = EMPTY_DICT def __init__(self, namespaces, extensions, error_log, enable_regexp, build_smart_strings): if extensions is not None and extensions: for ns_name_tuple, extension in extensions.items(): if ns_name_tuple[0] is None: raise XSLTExtensionError, \ "extensions must not have empty namespaces" if isinstance(extension, XSLTExtension): if self._extension_elements is EMPTY_DICT: self._extension_elements = {} extensions = extensions.copy() ns_utf = _utf8(ns_name_tuple[0]) name_utf = _utf8(ns_name_tuple[1]) self._extension_elements[(ns_utf, name_utf)] = extension del extensions[ns_name_tuple] _BaseContext.__init__(self, namespaces, extensions, error_log, enable_regexp, build_smart_strings) cdef _BaseContext _copy(self): cdef _XSLTContext context context = <_XSLTContext>_BaseContext._copy(self) context._extension_elements = self._extension_elements return context cdef register_context(self, xslt.xsltTransformContext* xsltCtxt, _Document doc): self._xsltCtxt = xsltCtxt self._set_xpath_context(xsltCtxt.xpathCtxt) self._register_context(doc) self.registerLocalFunctions(xsltCtxt, _register_xslt_function) self.registerGlobalFunctions(xsltCtxt, _register_xslt_function) _registerXSLTExtensions(xsltCtxt, self._extension_elements) cdef free_context(self): self._cleanup_context() self._release_context() if self._xsltCtxt is not NULL: xslt.xsltFreeTransformContext(self._xsltCtxt) self._xsltCtxt = NULL self._release_temp_refs() @cython.final @cython.internal @cython.freelist(8) cdef class _XSLTQuotedStringParam: """A wrapper class for literal XSLT string parameters that require quote escaping. """ cdef bytes strval def __cinit__(self, strval): self.strval = _utf8(strval) @cython.no_gc_clear cdef class XSLT: """XSLT(self, xslt_input, extensions=None, regexp=True, access_control=None) Turn an XSL document into an XSLT object. Calling this object on a tree or Element will execute the XSLT:: transform = etree.XSLT(xsl_tree) result = transform(xml_tree) Keyword arguments of the constructor: - extensions: a dict mapping ``(namespace, name)`` pairs to extension functions or extension elements - regexp: enable exslt regular expression support in XPath (default: True) - access_control: access restrictions for network or file system (see `XSLTAccessControl`) Keyword arguments of the XSLT call: - profile_run: enable XSLT profiling and make the profile available as XML document in ``result.xslt_profile`` (default: False) Other keyword arguments of the call are passed to the stylesheet as parameters. """ cdef _XSLTContext _context cdef xslt.xsltStylesheet* _c_style cdef _XSLTResolverContext _xslt_resolver_context cdef XSLTAccessControl _access_control cdef _ErrorLog _error_log def __cinit__(self): self._c_style = NULL def __init__(self, xslt_input, *, extensions=None, regexp=True, access_control=None): cdef xslt.xsltStylesheet* c_style = NULL cdef xmlDoc* c_doc cdef _Document doc cdef _Element root_node doc = _documentOrRaise(xslt_input) root_node = _rootNodeOrRaise(xslt_input) # set access control or raise TypeError self._access_control = access_control # make a copy of the document as stylesheet parsing modifies it c_doc = _copyDocRoot(doc._c_doc, root_node._c_node) # make sure we always have a stylesheet URL if c_doc.URL is NULL: doc_url_utf = python.PyUnicode_AsASCIIString( f"string://__STRING__XSLT__/{id(self)}.xslt") c_doc.URL = tree.xmlStrdup(_xcstr(doc_url_utf)) self._error_log = _ErrorLog() self._xslt_resolver_context = _XSLTResolverContext() _initXSLTResolverContext(self._xslt_resolver_context, doc._parser) # keep a copy in case we need to access the stylesheet via 'document()' self._xslt_resolver_context._c_style_doc = _copyDoc(c_doc, 1) c_doc._private = <python.PyObject*>self._xslt_resolver_context with self._error_log: orig_loader = _register_document_loader() c_style = xslt.xsltParseStylesheetDoc(c_doc) _reset_document_loader(orig_loader) if c_style is NULL or c_style.errors: tree.xmlFreeDoc(c_doc) if c_style is not NULL: xslt.xsltFreeStylesheet(c_style) self._xslt_resolver_context._raise_if_stored() # last error seems to be the most accurate here if self._error_log.last_error is not None and \ self._error_log.last_error.message: raise XSLTParseError(self._error_log.last_error.message, self._error_log) else: raise XSLTParseError( self._error_log._buildExceptionMessage( "Cannot parse stylesheet"), self._error_log) c_doc._private = NULL # no longer used! self._c_style = c_style self._context = _XSLTContext(None, extensions, self._error_log, regexp, True) def __dealloc__(self): if self._xslt_resolver_context is not None and \ self._xslt_resolver_context._c_style_doc is not NULL: tree.xmlFreeDoc(self._xslt_resolver_context._c_style_doc) # this cleans up the doc copy as well if self._c_style is not NULL: xslt.xsltFreeStylesheet(self._c_style) @property def error_log(self): """The log of errors and warnings of an XSLT execution.""" return self._error_log.copy() @staticmethod def strparam(strval): """strparam(strval) Mark an XSLT string parameter that requires quote escaping before passing it into the transformation. Use it like this:: result = transform(doc, some_strval = XSLT.strparam( '''it's \"Monty Python's\" ...''')) Escaped string parameters can be reused without restriction. """ return _XSLTQuotedStringParam(strval) @staticmethod def set_global_max_depth(int max_depth): """set_global_max_depth(max_depth) The maximum traversal depth that the stylesheet engine will allow. This does not only count the template recursion depth but also takes the number of variables/parameters into account. The required setting for a run depends on both the stylesheet and the input data. Example:: XSLT.set_global_max_depth(5000) Note that this is currently a global, module-wide setting because libxslt does not support it at a per-stylesheet level. """ if max_depth < 0: raise ValueError("cannot set a maximum stylesheet traversal depth < 0") xslt.xsltMaxDepth = max_depth def tostring(self, _ElementTree result_tree): """tostring(self, result_tree) Save result doc to string based on stylesheet output method. :deprecated: use str(result_tree) instead. """ return str(result_tree) def __deepcopy__(self, memo): return self.__copy__() def __copy__(self): return _copyXSLT(self) def __call__(self, _input, *, profile_run=False, **kw): """__call__(self, _input, profile_run=False, **kw) Execute the XSL transformation on a tree or Element. Pass the ``profile_run`` option to get profile information about the XSLT. The result of the XSLT will have a property xslt_profile that holds an XML tree with profiling data. """ cdef _XSLTContext context = None cdef _XSLTResolverContext resolver_context cdef _Document input_doc cdef _Element root_node cdef _Document result_doc cdef _Document profile_doc = None cdef xmlDoc* c_profile_doc cdef xslt.xsltTransformContext* transform_ctxt cdef xmlDoc* c_result = NULL cdef xmlDoc* c_doc cdef tree.xmlDict* c_dict cdef const_char** params = NULL assert self._c_style is not NULL, "XSLT stylesheet not initialised" input_doc = _documentOrRaise(_input) root_node = _rootNodeOrRaise(_input) c_doc = _fakeRootDoc(input_doc._c_doc, root_node._c_node) transform_ctxt = xslt.xsltNewTransformContext(self._c_style, c_doc) if transform_ctxt is NULL: _destroyFakeDoc(input_doc._c_doc, c_doc) raise MemoryError() # using the stylesheet dict is safer than using a possibly # unrelated dict from the current thread. Almost all # non-input tag/attr names will come from the stylesheet # anyway. if transform_ctxt.dict is not NULL: xmlparser.xmlDictFree(transform_ctxt.dict) if kw: # parameter values are stored in the dict # => avoid unnecessarily cluttering the global dict transform_ctxt.dict = xmlparser.xmlDictCreateSub(self._c_style.doc.dict) if transform_ctxt.dict is NULL: xslt.xsltFreeTransformContext(transform_ctxt) raise MemoryError() else: transform_ctxt.dict = self._c_style.doc.dict xmlparser.xmlDictReference(transform_ctxt.dict) xslt.xsltSetCtxtParseOptions( transform_ctxt, input_doc._parser._parse_options) if profile_run: transform_ctxt.profile = 1 try: context = self._context._copy() context.register_context(transform_ctxt, input_doc) resolver_context = self._xslt_resolver_context._copy() transform_ctxt._private = <python.PyObject*>resolver_context _convert_xslt_parameters(transform_ctxt, kw, &params) c_result = self._run_transform( c_doc, params, context, transform_ctxt) if params is not NULL: # deallocate space for parameters python.lxml_free(params) if transform_ctxt.state != xslt.XSLT_STATE_OK: if c_result is not NULL: tree.xmlFreeDoc(c_result) c_result = NULL if transform_ctxt.profile: c_profile_doc = xslt.xsltGetProfileInformation(transform_ctxt) if c_profile_doc is not NULL: profile_doc = _documentFactory( c_profile_doc, input_doc._parser) finally: if context is not None: context.free_context() _destroyFakeDoc(input_doc._c_doc, c_doc) try: if resolver_context is not None and resolver_context._has_raised(): if c_result is not NULL: tree.xmlFreeDoc(c_result) c_result = NULL resolver_context._raise_if_stored() if context._exc._has_raised(): if c_result is not NULL: tree.xmlFreeDoc(c_result) c_result = NULL context._exc._raise_if_stored() if c_result is NULL: # last error seems to be the most accurate here error = self._error_log.last_error if error is not None and error.message: if error.line > 0: message = f"{error.message}, line {error.line}" else: message = error.message elif error is not None and error.line > 0: message = f"Error applying stylesheet, line {error.line}" else: message = "Error applying stylesheet" raise XSLTApplyError(message, self._error_log) finally: if resolver_context is not None: resolver_context.clear() result_doc = _documentFactory(c_result, input_doc._parser) c_dict = c_result.dict xmlparser.xmlDictReference(c_dict) __GLOBAL_PARSER_CONTEXT.initThreadDictRef(&c_result.dict) if c_dict is not c_result.dict or \ self._c_style.doc.dict is not c_result.dict or \ input_doc._c_doc.dict is not c_result.dict: with nogil: if c_dict is not c_result.dict: fixThreadDictNames(<xmlNode*>c_result, c_dict, c_result.dict) if self._c_style.doc.dict is not c_result.dict: fixThreadDictNames(<xmlNode*>c_result, self._c_style.doc.dict, c_result.dict) if input_doc._c_doc.dict is not c_result.dict: fixThreadDictNames(<xmlNode*>c_result, input_doc._c_doc.dict, c_result.dict) xmlparser.xmlDictFree(c_dict) return _xsltResultTreeFactory(result_doc, self, profile_doc) cdef xmlDoc* _run_transform(self, xmlDoc* c_input_doc, const_char** params, _XSLTContext context, xslt.xsltTransformContext* transform_ctxt): cdef xmlDoc* c_result xslt.xsltSetTransformErrorFunc(transform_ctxt, <void*>self._error_log, <xmlerror.xmlGenericErrorFunc>_receiveXSLTError) if self._access_control is not None: self._access_control._register_in_context(transform_ctxt) with self._error_log, nogil: orig_loader = _register_document_loader() c_result = xslt.xsltApplyStylesheetUser( self._c_style, c_input_doc, params, NULL, NULL, transform_ctxt) _reset_document_loader(orig_loader) return c_result cdef _convert_xslt_parameters(xslt.xsltTransformContext* transform_ctxt, dict parameters, const_char*** params_ptr): cdef Py_ssize_t i, parameter_count cdef const_char** params cdef tree.xmlDict* c_dict = transform_ctxt.dict params_ptr[0] = NULL parameter_count = len(parameters) if parameter_count == 0: return # allocate space for parameters # * 2 as we want an entry for both key and value, # and + 1 as array is NULL terminated params = <const_char**>python.lxml_malloc(parameter_count * 2 + 1, sizeof(const_char*)) if not params: raise MemoryError() try: i = 0 for key, value in parameters.iteritems(): k = _utf8(key) if isinstance(value, _XSLTQuotedStringParam): v = (<_XSLTQuotedStringParam>value).strval xslt.xsltQuoteOneUserParam( transform_ctxt, _xcstr(k), _xcstr(v)) else: if isinstance(value, XPath): v = (<XPath>value)._path else: v = _utf8(value) params[i] = <const_char*>tree.xmlDictLookup(c_dict, _xcstr(k), len(k)) i += 1 params[i] = <const_char*>tree.xmlDictLookup(c_dict, _xcstr(v), len(v)) i += 1 except: python.lxml_free(params) raise params[i] = NULL params_ptr[0] = params cdef XSLT _copyXSLT(XSLT stylesheet): cdef XSLT new_xslt cdef xmlDoc* c_doc assert stylesheet._c_style is not NULL, "XSLT stylesheet not initialised" new_xslt = XSLT.__new__(XSLT) new_xslt._access_control = stylesheet._access_control new_xslt._error_log = _ErrorLog() new_xslt._context = stylesheet._context._copy() new_xslt._xslt_resolver_context = stylesheet._xslt_resolver_context._copy() new_xslt._xslt_resolver_context._c_style_doc = _copyDoc( stylesheet._xslt_resolver_context._c_style_doc, 1) c_doc = _copyDoc(stylesheet._c_style.doc, 1) new_xslt._c_style = xslt.xsltParseStylesheetDoc(c_doc) if new_xslt._c_style is NULL: tree.xmlFreeDoc(c_doc) raise MemoryError() return new_xslt @cython.final cdef class _XSLTResultTree(_ElementTree): """The result of an XSLT evaluation. Use ``str()`` or ``bytes()`` (or ``unicode()`` in Python 2.x) to serialise to a string, and the ``.write_output()`` method to write serialise to a file. """ cdef XSLT _xslt cdef _Document _profile cdef xmlChar* _buffer cdef Py_ssize_t _buffer_len cdef Py_ssize_t _buffer_refcnt def write_output(self, file, *, compression=0): """write_output(self, file, *, compression=0) Serialise the XSLT output to a file or file-like object. As opposed to the generic ``.write()`` method, ``.write_output()`` serialises the result as defined by the ``<xsl:output>`` tag. """ cdef _FilelikeWriter writer = None cdef _Document doc cdef int r, rclose, c_compression cdef const_xmlChar* c_encoding = NULL cdef tree.xmlOutputBuffer* c_buffer if self._context_node is not None: doc = self._context_node._doc else: doc = None if doc is None: doc = self._doc if doc is None: raise XSLTSaveError("No document to serialise") c_compression = compression or 0 xslt.LXML_GET_XSLT_ENCODING(c_encoding, self._xslt._c_style) writer = _create_output_buffer(file, <const_char*>c_encoding, compression, &c_buffer, close=False) if writer is None: with nogil: r = xslt.xsltSaveResultTo(c_buffer, doc._c_doc, self._xslt._c_style) rclose = tree.xmlOutputBufferClose(c_buffer) else: r = xslt.xsltSaveResultTo(c_buffer, doc._c_doc, self._xslt._c_style) rclose = tree.xmlOutputBufferClose(c_buffer) if writer is not None: writer._exc_context._raise_if_stored() if r < 0 or rclose == -1: python.PyErr_SetFromErrno(IOError) # raises IOError cdef _saveToStringAndSize(self, xmlChar** s, int* l): cdef _Document doc cdef int r if self._context_node is not None: doc = self._context_node._doc else: doc = None if doc is None: doc = self._doc if doc is None: s[0] = NULL return with nogil: r = xslt.xsltSaveResultToString(s, l, doc._c_doc, self._xslt._c_style) if r == -1: raise MemoryError() def __str__(self): cdef xmlChar* encoding cdef xmlChar* s = NULL cdef int l = 0 self._saveToStringAndSize(&s, &l) if s is NULL: return '' encoding = self._xslt._c_style.encoding try: if encoding is NULL: result = s[:l].decode('UTF-8') else: result = s[:l].decode(encoding) finally: tree.xmlFree(s) return _stripEncodingDeclaration(result) def __getbuffer__(self, Py_buffer* buffer, int flags): cdef int l = 0 if buffer is NULL: return if self._buffer is NULL or flags & python.PyBUF_WRITABLE: self._saveToStringAndSize(<xmlChar**>&buffer.buf, &l) buffer.len = l if self._buffer is NULL and not flags & python.PyBUF_WRITABLE: self._buffer = <xmlChar*>buffer.buf self._buffer_len = l self._buffer_refcnt = 1 else: buffer.buf = self._buffer buffer.len = self._buffer_len self._buffer_refcnt += 1 if flags & python.PyBUF_WRITABLE: buffer.readonly = 0 else: buffer.readonly = 1 if flags & python.PyBUF_FORMAT: buffer.format = "B" else: buffer.format = NULL buffer.ndim = 0 buffer.shape = NULL buffer.strides = NULL buffer.suboffsets = NULL buffer.itemsize = 1 buffer.internal = NULL if buffer.obj is not self: # set by Cython? buffer.obj = self def __releasebuffer__(self, Py_buffer* buffer): if buffer is NULL: return if <xmlChar*>buffer.buf is self._buffer: self._buffer_refcnt -= 1 if self._buffer_refcnt == 0: tree.xmlFree(<char*>self._buffer) self._buffer = NULL else: tree.xmlFree(<char*>buffer.buf) buffer.buf = NULL property xslt_profile: """Return an ElementTree with profiling data for the stylesheet run. """ def __get__(self): cdef object root if self._profile is None: return None root = self._profile.getroot() if root is None: return None return ElementTree(root) def __del__(self): self._profile = None cdef _xsltResultTreeFactory(_Document doc, XSLT xslt, _Document profile): cdef _XSLTResultTree result result = <_XSLTResultTree>_newElementTree(doc, None, _XSLTResultTree) result._xslt = xslt result._profile = profile return result # functions like "output" and "write" are a potential security risk, but we # rely on the user to configure XSLTAccessControl as needed xslt.xsltRegisterAllExtras() # enable EXSLT support for XSLT xslt.exsltRegisterAll() ################################################################################ # XSLT PI support cdef object _RE_PI_HREF = re.compile(r'\s+href\s*=\s*(?:\'([^\']*)\'|"([^"]*)")') cdef object _FIND_PI_HREF = _RE_PI_HREF.findall cdef object _REPLACE_PI_HREF = _RE_PI_HREF.sub cdef XPath __findStylesheetByID = None cdef _findStylesheetByID(_Document doc, id): global __findStylesheetByID if __findStylesheetByID is None: __findStylesheetByID = XPath( "//xsl:stylesheet[@xml:id = $id]", namespaces={"xsl" : "http://www.w3.org/1999/XSL/Transform"}) return __findStylesheetByID(doc, id=id) cdef class _XSLTProcessingInstruction(PIBase): def parseXSL(self, parser=None): """parseXSL(self, parser=None) Try to parse the stylesheet referenced by this PI and return an ElementTree for it. If the stylesheet is embedded in the same document (referenced via xml:id), find and return an ElementTree for the stylesheet Element. The optional ``parser`` keyword argument can be passed to specify the parser used to read from external stylesheet URLs. """ cdef _Document result_doc cdef _Element result_node cdef bytes href_utf cdef const_xmlChar* c_href cdef xmlAttr* c_attr _assertValidNode(self) if self._c_node.content is NULL: raise ValueError, "PI lacks content" hrefs = _FIND_PI_HREF(' ' + (<unsigned char*>self._c_node.content).decode('UTF-8')) if len(hrefs) != 1: raise ValueError, "malformed PI attributes" hrefs = hrefs[0] href_utf = utf8(hrefs[0] or hrefs[1]) c_href = _xcstr(href_utf) if c_href[0] != c'#': # normal URL, try to parse from it c_href = tree.xmlBuildURI( c_href, tree.xmlNodeGetBase(self._c_node.doc, self._c_node)) if c_href is not NULL: try: href_utf = <unsigned char*>c_href finally: tree.xmlFree(<char*>c_href) result_doc = _parseDocumentFromURL(href_utf, parser) return _elementTreeFactory(result_doc, None) # ID reference to embedded stylesheet # try XML:ID lookup _assertValidDoc(self._doc) c_href += 1 # skip leading '#' c_attr = tree.xmlGetID(self._c_node.doc, c_href) if c_attr is not NULL and c_attr.doc is self._c_node.doc: result_node = _elementFactory(self._doc, c_attr.parent) return _elementTreeFactory(result_node._doc, result_node) # try XPath search root = _findStylesheetByID(self._doc, funicode(c_href)) if not root: raise ValueError, "reference to non-existing embedded stylesheet" elif len(root) > 1: raise ValueError, "ambiguous reference to embedded stylesheet" result_node = root[0] return _elementTreeFactory(result_node._doc, result_node) def set(self, key, value): """set(self, key, value) Supports setting the 'href' pseudo-attribute in the text of the processing instruction. """ if key != "href": raise AttributeError, \ "only setting the 'href' attribute is supported on XSLT-PIs" if value is None: attrib = "" elif '"' in value or '>' in value: raise ValueError, "Invalid URL, must not contain '\"' or '>'" else: attrib = f' href="{value}"' text = ' ' + self.text if _FIND_PI_HREF(text): self.text = _REPLACE_PI_HREF(attrib, text) else: self.text = text + attrib