| |
| 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. |
| """ |
|
|
|
|
| |
| LIBXSLT_COMPILED_VERSION = __unpackIntVersion(xslt.LIBXSLT_VERSION) |
| LIBXSLT_VERSION = __unpackIntVersion(xslt.xsltLibxsltVersion) |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
|
|
| |
| |
|
|
| @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: |
| |
| 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 |
|
|
| |
| 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 |
|
|
| |
| 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 |
|
|
|
|
| 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 |
|
|
|
|
| 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: |
| |
| cdef xmlDoc* c_doc |
| cdef xmlDoc* result |
| cdef void* c_pcontext |
| cdef int error = 0 |
| |
| if c_type == xslt.XSLT_LOAD_DOCUMENT: |
| |
| c_pcontext = (<xslt.xsltTransformContext*>c_ctxt)._private |
| elif c_type == xslt.XSLT_LOAD_STYLESHEET: |
| |
| c_pcontext = (<xslt.xsltStylesheet*>c_ctxt).doc._private |
| else: |
| c_pcontext = NULL |
|
|
| if c_pcontext is NULL: |
| |
| 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) |
|
|
| |
| |
|
|
| 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])) |
|
|
| |
| |
|
|
| cdef int _register_xslt_function(void* ctxt, name_utf, ns_utf) noexcept: |
| if ns_utf is None: |
| return 0 |
| |
| 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) |
|
|
| |
| self._access_control = access_control |
|
|
| |
| c_doc = _copyDocRoot(doc._c_doc, root_node._c_node) |
|
|
| |
| 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) |
| |
| 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() |
| |
| 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 |
| 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) |
| |
| 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() |
|
|
| |
| |
| |
| |
| if transform_ctxt.dict is not NULL: |
| xmlparser.xmlDictFree(transform_ctxt.dict) |
| if kw: |
| |
| |
| 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, ¶ms) |
| c_result = self._run_transform( |
| c_doc, params, context, transform_ctxt) |
| if params is not NULL: |
| |
| 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: |
| |
| 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 |
| |
| |
| |
| 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) |
|
|
| 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: |
| 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 |
|
|
| |
| |
| xslt.xsltRegisterAllExtras() |
|
|
| |
| xslt.exsltRegisterAll() |
|
|
|
|
| |
| |
|
|
| 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'#': |
| |
| 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) |
|
|
| |
| |
| _assertValidDoc(self._doc) |
| c_href += 1 |
| 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) |
|
|
| |
| 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 |
|
|
