def __call__(self, _input, profile_run=False, **kw):
nsmap = dict(xsl='http://www.w3.org/1999/XSL/Transform')
output_method = 'xml'
output_encoding = 'utf-8'
nodes = self.xsl_tree.xpath('xsl:output/@method', namespaces=nsmap)
if len(nodes) > 0:
output_method = nodes[0]
nodes = self.xsl_tree.xpath('xsl:output/@encoding', namespaces=nsmap)
if len(nodes) > 0:
output_encoding = nodes[0]
#print tostring(_input)
if isinstance(_input, _ElementTree):
doc_source = DOMSource(_input._dom_doc)
elif isinstance(_input, _Element):
# Xalan-J 2.7.1 does not support a DOMSource from an Element
# so we build new document
dom_doc = builder.newDocument()
dom_root = dom_doc.importNode(_input._dom_element, True)
dom_doc.appendChild(dom_root)
doc_source = DOMSource(dom_doc)
else:
raise NotImplementedError()
if output_method in ('xml', 'html'):
# TODO: for testing
outputstream = ByteArrayOutputStream()
result = StreamResult(outputstream)
self.transformer.transform(doc_source, result)
bytes = outputstream.toByteArray()
inputstream = ByteArrayInputStream(bytes)
try:
dom_doc = builder.parse(inputstream)
except:
import sys
sys.stderr.write(bytes.tostring())
raise
result_tree = _ElementTree(dom_doc)
return result_tree
result = DOMResult()
self.transformer.transform(doc_source, result)
dom_doc = result.getNode()
result_tree = _ElementTree(dom_doc)
#print tostring(result_tree)
return result_tree
else:
outputstream = ByteArrayOutputStream()
result = StreamResult(outputstream)
self.transformer.transform(doc_source, result)
resultdoc = builder.newDocument()
resulttree = _XSLTResultTree(resultdoc)
resulttree._text = outputstream.toString(output_encoding)
return resulttree
def tostring(element_or_tree,
encoding=None,
method='xml',
xml_declaration=None,
pretty_print=False,
with_tail=True,
standalone=None,
doctype=None,
exclusive=False,
with_comments=True,
inclusive_ns_prefixes=None):
if isinstance(element_or_tree, _ElementTree):
source = DOMSource(element_or_tree._dom_doc)
else:
source = DOMSource(element_or_tree._dom_element)
outputstream = ByteArrayOutputStream()
result = StreamResult(outputstream)
transformer = transformfac.newTransformer()
if xml_declaration:
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, 'no')
else:
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, 'yes')
if pretty_print:
transformer.setOutputProperty(OutputKeys.INDENT, 'yes')
else:
transformer.setOutputProperty(OutputKeys.INDENT, 'no')
transformer.transform(source, result)
if encoding is None:
encoding = 'ascii'
return outputstream.toString(encoding)
def _transform(self, input, output):
from javax.xml.transform.stream import StreamSource
from javax.xml.transform.stream import StreamResult
inp_source = StreamSource(input)
out_result = StreamResult(output)
self.transformer.transform(inp_source, out_result)
return dict()
def transformReport(self, stylesheet, xml, output, params):
from java.io import FileInputStream
from java.io import FileOutputStream
from java.io import ByteArrayOutputStream
from javax.xml.transform import TransformerFactory
from javax.xml.transform.stream import StreamSource
from javax.xml.transform.stream import StreamResult
self.xsl = FileInputStream("%s" % stylesheet)
self.xml = FileInputStream("%s" % xml)
self.html = FileOutputStream("%s" % output)
try:
self.xslSource = StreamSource(self.xsl)
self.tfactory = TransformerFactory.newInstance()
self.xslTemplate = self.tfactory.newTemplates(self.xslSource)
self.transformer = self.xslTemplate.newTransformer()
self.source = StreamSource(self.xml)
self.result = StreamResult(self.html)
for self.key, self.value in params.items():
self.transformer.setParameter(self.key, self.value)
self.transformer.transform(self.source, self.result)
finally:
self.xsl.close()
self.xml.close()
self.html.close()
def toFile(self, doc, filename): source = DOMSource(doc) file = File(filename); result = StreamResult(file); xformer = TransformerFactory.newInstance().newTransformer(); xformer.transform(source, result);
def handle(self):
try:
raw_xml = self.rfile.readline().strip()
marc_xmlfile = NamedTemporaryFile(delete=False)
marc_xmlfile.write(raw_xml)
marc_xmlfile.close()
print(marc_xmlfile.name)
dynamic_context = saxon.query.DynamicQueryContext(CONFIG)
## xml_doc = CONFIG.buildDocument(
## StreamSource(ByteArrayInputStream(raw_xml)))
## dynamic_context.setContextItem(xml_doc)
dynamic_context.setParameter(
"baseuri",
INFO.get('base_uri', 'http://catalog/'))
dynamic_context.setParameter(
"marcxmluri",
os.path.normpath(marc_xmlfile.name).replace("\\", "/"))
dynamic_context.setParameter("serialization", "rdfxml")
output_stream = ByteArrayOutputStream()
result = StreamResult(output_stream)
print("Before query")
COMPLIED_XQUERY.run(dynamic_context, result, None)
self.wfile.write(output_stream.toString().encode('ascii',
errors='ignore'))
os.remove(marc_xmlfile.name)
except:
self.wfile.write("Error processing MARC XML:\n\t{}".format(sys.exc_info()[0]))
def __toXMLString(self, document):
domSource = DOMSource(document)
writer = StringWriter()
result = StreamResult(writer)
tf = TransformerFactory.newInstance()
transformer = tf.newTransformer()
transformer.transform(domSource, result)
return writer.toString()
def transform(inp_path, out_path):
inp_path = os.path.abspath(inp_path)
out_path = os.path.abspath(out_path)
inp_fis = FileInputStream(inp_path)
out_fos = FileOutputStream(out_path)
inp_source = StreamSource(inp_fis)
out_result = StreamResult(out_fos)
transformer.transform(inp_source, out_result)
return dict()
def __init__(self, path):
self.path = path
self._output = FileOutputStream(path)
self._writer = SAXTransformerFactory.newInstance(
).newTransformerHandler()
self._writer.setResult(StreamResult(self._output))
self._writer.startDocument()
self.content('\n')
self.closed = False
def printXMLfile(self,doc):
try:
from javax.xml.transform import TransformerFactory
from javax.xml.transform import OutputKeys
from javax.xml.transform.stream import StreamSource
from javax.xml.transform.stream import StreamResult
from javax.xml.transform.dom import DOMSource
from java.io import StringWriter
xmlInput = DOMSource(doc);
xmlOutput = StreamResult(StringWriter());
tranFactory = TransformerFactory.newInstance();
aTransformer = tranFactory.newTransformer();
aTransformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8")
aTransformer.setOutputProperty(OutputKeys.INDENT, "yes");
aTransformer.transform(xmlInput, xmlOutput);
print xmlOutput.getWriter().toString()
except:
print "exception: %s" % traceback.format_exception(*sys.exc_info())
def printXMLfile(self, doc):
try:
from javax.xml.transform import TransformerFactory
from javax.xml.transform import OutputKeys
from javax.xml.transform.stream import StreamSource
from javax.xml.transform.stream import StreamResult
from javax.xml.transform.dom import DOMSource
from java.io import StringWriter
xmlInput = DOMSource(doc)
xmlOutput = StreamResult(StringWriter())
tranFactory = TransformerFactory.newInstance()
aTransformer = tranFactory.newTransformer()
aTransformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8")
aTransformer.setOutputProperty(OutputKeys.INDENT, "yes")
aTransformer.transform(xmlInput, xmlOutput)
print xmlOutput.getWriter().toString()
except:
print "exception: %s" % traceback.format_exception(*sys.exc_info())
def __call__(self, _input, profile_run=False, **kw):
nsmap = dict(xsl='http://www.w3.org/1999/XSL/Transform')
output_method = 'xml'
output_encoding = 'utf-8'
nodes = self.xsl_tree.xpath('xsl:output/@method', namespaces=nsmap)
if len(nodes) > 0:
output_method = nodes[0]
nodes = self.xsl_tree.xpath('xsl:output/@encoding', namespaces=nsmap)
if len(nodes) > 0:
output_encoding = nodes[0]
#print tostring(_input)
if isinstance(_input, _ElementTree):
doc_source = DOMSource(_input._dom_doc)
elif isinstance(_input, _Element):
# Xalan-J 2.7.1 does not support a DOMSource from an Element
# so we build new document
dom_doc = builder.newDocument()
dom_root = dom_doc.importNode(_input._dom_element, True)
dom_doc.appendChild(dom_root)
doc_source = DOMSource(dom_doc)
else:
raise NotImplementedError()
if output_method in ('xml', 'html'):
# TODO: for testing
outputstream = ByteArrayOutputStream()
result = StreamResult(outputstream)
self.transformer.transform(doc_source, result)
bytes = outputstream.toByteArray()
inputstream = ByteArrayInputStream(bytes)
try:
dom_doc = builder.parse(inputstream)
except:
import sys
sys.stderr.write(bytes.tostring())
raise
result_tree = _ElementTree(dom_doc)
return result_tree
result = DOMResult()
self.transformer.transform(doc_source, result)
dom_doc = result.getNode()
result_tree = _ElementTree(dom_doc)
#print tostring(result_tree)
return result_tree
else:
outputstream = ByteArrayOutputStream()
result = StreamResult(outputstream)
self.transformer.transform(doc_source, result)
resultdoc = builder.newDocument()
resulttree = _XSLTResultTree(resultdoc)
resulttree._text = outputstream.toString(output_encoding)
return resulttree
def writeXMLfile(self, doc, xmlfile):
try:
import sys, traceback
from java.io import File
from javax.xml.transform import TransformerFactory
from javax.xml.transform import OutputKeys
from javax.xml.transform.stream import StreamResult
from javax.xml.transform.dom import DOMSource
tranFactory = TransformerFactory.newInstance()
aTransformer = tranFactory.newTransformer()
aTransformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8")
aTransformer.setOutputProperty(OutputKeys.INDENT, "yes")
src = DOMSource(doc)
dest = StreamResult(File(xmlfile))
aTransformer.transform(src, dest)
except:
print "exception: %s" % traceback.format_exception(*sys.exc_info())
def DoXPath (Filename,XPathString): IS = InputSource (FileInputStream (Filename)) df = DocumentBuilderFactory.newInstance() df.setNamespaceAware(1) doc = df.newDocumentBuilder().parse(IS) serializer = TransformerFactory.newInstance().newTransformer() serializer.setOutputProperty (OutputKeys.OMIT_XML_DECLARATION, "yes") nl = XPathAPI.selectNodeIterator (doc,XPathString) n = nl.nextNode() while n: if IsTextNode (n): # Coalesce contiguous text nodes res = [n.getNodeValue()] nn = n.getNextSibling() while (nn): res.append (nn.getNodeValue()) nn = n.getNextSibling() java.lang.System.out (string.join(res,"")) else: serializer.transform (DOMSource(n), StreamResult (OutputStreamWriter (java.lang.System.out))) java.lang.System.out.println() n = nl.nextNode()
def handler(environ, start_response):
reload(sys)
sys.setdefaultencoding('UTF8')
welcomeString = "<html><head><title>atom2rss converter • Atom to RSS2 converter</title><style>body { padding: 20px 40px; font-family: Verdana, Helvetica, Sans-Serif; font-size: medium; }</style></head><body><form method=\"post\"><h1>atom2rss converter written with Jython</h1><p>This tool will let you convert your atom 1.0 feed into an RSS2 feed that can be imported into WordPress.</p><p>Please read the full instructions before starting.</p><p><input type=\"text\" name=\"atom\" style=\"width: 400px;\"><input type=\"submit\" value=\"Convert\"></p><h2>Instructions</h2><p><strong>Step 1</strong>: Enter the url of an atom feed urls, e.g. <i>http://yoursite.com/atom.xml</i><br /></p><p><strong>Step 2</strong>: After clicking the \"Convert\" button, head to File / Save As... and save the file as rss.xml to your desktop.</p><p><strong>Step 3</strong>: Use this rss.xml file to import your data into WordPress under Import / RSS.</p><h2>About</h2><p>This tool is online as a convenience designed by <a href=\"http://kevin.9511.net/\">Kevin Li</a>.</p><p>Your can use it to import GoogleReader or Blogger data into Wordpress.</p></form></body></html>"
response_parts = []
header_str = ''
if environ['REQUEST_METHOD'] == 'POST':
post = environ['j2ee.request']
if post.getParameterValues('atom') is None:
bs = welcomeString
else:
try:
atom = post.getParameterValues('atom')[0]
atomUrl = URL(str(atom))
atomSource = StreamSource(
InputStreamReader(atomUrl.openStream(), "utf-8"))
file = open(os.path.join(os.getcwd(), 'webapp/atom2rss.xsl'))
xsltString = file.read()
file.close()
xsltSource = StreamSource(StringReader(xsltString))
outputBuffer = StringWriter()
transFactory = javax.xml.transform.TransformerFactory.newInstance(
"org.apache.xalan.processor.TransformerFactoryImpl",
Thread.currentThread().getContextClassLoader())
transformer = transFactory.newTransformer(xsltSource)
transformer.transform(atomSource, StreamResult(outputBuffer))
bs = outputBuffer.buffer.toString()
header_str = 'text/xml;charset=utf-8'
except MalformedURLException, mue:
bs = "url format error"
except TransformerException, te:
bs = "transforme failed"
except IOException, ie:
bs = ie.getMessage()
transformer.transform(source, result)
args = sys.argv[1:]
parameters = []
while args and args[0].startswith('-'):
try:
i = args[0].index('=')
except ValueError:
parameters.append((args[0], ""))
else:
parameters.append((args[0][1:i], args[0][i+1:]))
args = args[1:]
if len(args) == 1: source = StreamSource(System.in)
elif len(args) >= 2: source = StreamSource(FileReader(args[1]))
else: raise "Usage: <jython|wlst> transform.py -<parameter>=<value> <stylesheetfile> [inputfile] [outputfile]"
if len(args) == 3: output = args[2]
else: output = ""
stylesheet = StreamSource(FileReader(args[0]))
if len(output) == 0:
result = StreamResult(PrintWriter(System.out))
else:
result = StreamResult(FileWriter(File(output)))
transform(source, stylesheet, result, parameters)
stylesheet.reader.close()
source.reader and source.reader.close()
result.writer.close()
def transform(src_source):
outputstream = ByteArrayOutputStream()
dst_result = StreamResult(outputstream)
transformer.transform(src_source, dst_result)
return ''.join(chr(unsigned_byte(x)) for x in outputstream.toByteArray())
print '*' * 70
print 'This is likely that your license file for saxon is '\
'missing or that there is a genuine error in the XSLT'
sys.exit(1)
_count = _count + 1
if _count % 1000 == 0:
System.gc()
fid, path, = tempfile.mkstemp()
os.close(fid)
try:
print '\r + Processing document %s' % (docuuid, ),
_transform.transform(StreamSource(StringReader(xmldoc)),
StreamResult(JavaFile(path)))
f = open(path)
store_document_result(f.read(), docuuid)
f.close()
os.remove(path)
except TransformerException, e:
_errors = _errors + 1
msg = "Error: %s\nDoc UUID: %s\n" % (e, docuuid)
store_document_result("", docuuid, msg)
logging.error(msg)
def get_document_count(connection):
'''
Counts how many records are available for us to process
txt=responseBuilder.toString();
'''
dbf = DocumentBuilderFactory.newInstance()
db = dbf.newDocumentBuilder()
doc = db.parse(url.openStream())
value = doc.getElementsByTagName('Terminal').item(1).item(
1).getFirstChild().getNodeValue()
lg = float(value)
print lg
source = DOMSource(doc)
file = File("/tmp/aaa.xml")
result = StreamResult(file)
xformer = TransformerFactory.newInstance().newTransformer()
xformer.transform(source, result)
'''
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<Response>
<Terminal>
<Name>FundamentalEnableFeedback</Name>
<Value>1</Value>
</Terminal>
<Terminal><Name>LoopGainFeedback</Name><Value>79</Value>
</Terminal><Terminal><Name>HarmPhaseShiftFeedback</Name><Value>39754</Value></Terminal>
<Terminal><Name>FundPhaseShiftFeedback</Name><Value>42977</Value></Terminal>
<Terminal><Name>DelaySetValueFeedback</Name><Value>0.000000</Value></Terminal>
</Response>
def xsltHtml(xslt,xmlcontent) :
transformer = _getTransformer(xslt)
out = ByteArrayOutputStream()
reader = StringReader(xmlcontent)
transformer.transform(StreamSource(reader),StreamResult(out))
return out
