def Parse(self, data, isfinal=False):
# The 'data' argument should be an encoded text: a str instance that
# represents an array of bytes. If instead it is a unicode string,
# only the us-ascii range is considered safe enough to be silently
# converted.
if isinstance(data, unicode):
data = data.encode(sys.getdefaultencoding())
self._data.append(data)
if isfinal:
bytes = StringUtil.toBytes(self._data.toString())
byte_stream = ByteArrayInputStream(bytes)
source = InputSource(byte_stream)
if self.encoding is not None:
source.setEncoding(self.encoding)
try:
self._reader.parse(source)
except SAXParseException, sax_error:
# Experiments tend to show that the '_Next*' parser locations
# match more closely expat behavior than the 'Current*' or sax
# error locations.
self.ErrorLineNumber = self._NextLineNumber
self.ErrorColumnNumber = self._NextColumnNumber
self.ErrorCode = None
raise self._expat_error(sax_error)
return 1
def _createReader(self, path, value, xmlWriter):
u'''функция создания ридера для чтения файла настроек, с учетом указанного пути'''
pathList = list()
name = r"[a-zA-Z_][a-zA-Z_0-9]+"
elementPatern = regexp.compile(r"""(%s)(?:\[(?:@(%s)=(?:'([^']+)'|\"([^\"]+)\")|([0-9]+))\])?(?:/@(%s))?""" % (name, name, name), regexp.UNICODE)
lastEnd = -1
for a in elementPatern.finditer(unicode(path)):
if lastEnd + 1 != a.start(0) or (lastEnd > 0 and path[lastEnd]not in ('/', '\\')):
raise CelestaException('Bad XPath expression')
pathList.append(NodeProperties(a.groups()))
lastEnd = a.end(0)
parser = XMLReaderFactory.createXMLReader()
handler = WriteSettings(pathList, xmlWriter, value)
parser.setContentHandler(handler)
parser.setErrorHandler(handler)
parser.setFeature("http://xml.org/sax/features/namespace-prefixes", True)
parser.setProperty("http://xml.org/sax/properties/lexical-handler", handler)
stream = FileInputStream(self._getUserSettingsFilePath())
parser.parse(InputSource(stream))
stream.close()
if not handler.result:
stream = FileInputStream(self._getSettingsFilePath())
parser.parse(InputSource(stream))
stream.close()
return handler.result
def Parse(self, data, isfinal=False):
# The 'data' argument should be an encoded text: a str instance that
# represents an array of bytes. If instead it is a unicode string,
# only the us-ascii range is considered safe enough to be silently
# converted.
if isinstance(data, unicode):
data = data.encode(sys.getdefaultencoding())
self._data.append(data)
if isfinal:
bytes = StringUtil.toBytes(self._data.toString())
byte_stream = ByteArrayInputStream(bytes)
source = InputSource(byte_stream)
if self.encoding is not None:
source.setEncoding(self.encoding)
try:
self._reader.parse(source)
except SAXParseException, sax_error:
# Experiments tend to show that the '_Next*' parser locations
# match more closely expat behavior than the 'Current*' or sax
# error locations.
self.ErrorLineNumber = self._NextLineNumber
self.ErrorColumnNumber = self._NextColumnNumber
self.ErrorCode = None
raise self._expat_error(sax_error)
return 1
def authorizeFortress(self, user_name):
responseData = self.getFortressResponse(user_name)
print responseData
dbf = DocumentBuilderFactory.newInstance()
fortressAuthenticated = False
db = None
try:
db = dbf.newDocumentBuilder()
print responseData
isource = InputSource()
isource.setCharacterStream(StringReader(responseData))
try:
doc = db.parse(isource)
errorCode = doc.getElementsByTagName("errorCode")
valueSet = doc.getElementsByTagName("valueSet")
if (errorCode.item(0).getTextContent() == "0"
and self.roleExists("GLUU_ADMIN", valueSet)):
return True
else:
fortressAuthenticated = False
except Exception, ex:
print "Exception"
except ParserConfigurationException, pce:
print pce
def endElement(self, uri, lname, qname):
if self.state == 1 and uri == "http://www.w3.org/2002/xforms" and lname == "model":
#вставка биндов для правил в mainModel
stream = FileInputStream(self.bindPath)
self.parser.parse(InputSource(stream))
self.state = 0
self.xmlWriter.writeEndElement()
def getXMLcontent(result):
parser = DOMParser()
parser.reset()
parser.parse(InputSource(result.inputStream))
root = parser.getDocument().getDocumentElement()
return root
def readConfig(self, fh=None, xml=None):
self.fh = fh
self.xml = xml
self.tree = None
self.doc = None
self.cellTree = None
if self.fh != None:
self.logger.info("readConfig: processing xml file")
self.logger.debug("readConfig: file %s " % fh)
input = FileInputStream(self.fh)
fhtree = builder.parse(input)
self.tree = fhtree.getDocumentElement()
self.cellTree = fhtree.getElementById('Cell')
elif self.xml != None:
self.logger.info("readConfig: processing xml String")
str = StringReader(xml)
strstrm = InputSource(str)
self.doc = builder.parse(strstrm)
self.tree = self.doc.getDocumentElement()
self.cellTree = self.doc.getElementById('Cell')
else:
self.logger.error("readConfig: You did not supply a valid xml file handle or xml string to the readConfig method.")
raise ProcessConfigException("readConfig: You did not supply a valid xml file handle or xml string to the readConfig method.")
self.logger.debug("readConfig: self.tree = %s" % (self.tree))
self.treeDict = []
self.logger.debug("readConfig: processing base tree elements")
self.logger.debug("readConfig: self.tree: %s " % self.tree)
self.walkXMLTree(self.tree, 0)
self.logger.debug("readConfig: self.treeDict = %s" % (self.treeDict))
return self.treeDict
def mainproc():
u'''Функция для склейки карточки с блоками правил'''
try:
rootPath = AppInfoSingleton.getAppInfo().getCurUserData().getPath(
) + '/xforms/'
except:
rootPath = 'E:/Projects/celesta/ssmmd/userscore/ssmmd/xforms/file/'
templatePath = rootPath + add #путь к карточке, в которую необходимо вставить праила
rulePath = rootPath + 'ruleTemplate.xml' #путь к блоку с правилами
bindPath = rootPath + 'bindTemplate.xml' #путь к блоку с биндами для правил
stringWriter = StringWriter()
xmlWriter = XMLOutputFactory.newInstance().createXMLStreamWriter(
stringWriter)
parser = XMLReaderFactory.createXMLReader()
handler = XformsAddRules(rulePath, bindPath, xmlWriter)
parser.setContentHandler(handler)
parser.setErrorHandler(handler)
parser.setFeature("http://xml.org/sax/features/namespace-prefixes", True)
parser.setProperty("http://xml.org/sax/properties/lexical-handler",
handler)
stream = FileInputStream(templatePath)
parser.parse(InputSource(stream))
xmlWriter.close()
stringWriter.close()
return unicode(stringWriter)
def __call__(self):
if grinder.runNumber > 0 or grinder.threadNumber > 0:
raise RuntimeError("Use limited to one thread, one run; "
"see Amazon Web Services terms and conditions")
request = HTTPRequest(url="http://xml.amazon.com/onca/xml")
bookDetailsTest.record(request)
parameters = (
NVPair("v", "1.0"),
NVPair("f", "xml"),
NVPair("t", "webservices-20"),
NVPair("dev-t", "<insert license key here>"),
NVPair("type", "heavy"),
NVPair("AsinSearch", "1904284000"),
)
bytes = request.POST(parameters).inputStream
# Parse results
document = parser.buildDocumentUrl(InputSource(bytes))
result = {}
for details in document.getElementsByTagName("Details"):
for detailName in ("ProductName", "SalesRank", "ListPrice"):
result[detailName] = details.getElementsByTagName(
detailName)[0].firstChild.nodeValue
grinder.logger.info(str(result))
def extractRootElement(self):
"""Setup an XML parser
"""
dbf = DocumentBuilderFactory.newInstance()
dbf.setNamespaceAware(1)
domparser = dbf.newDocumentBuilder()
doc = domparser.parse(InputSource(StringReader(self.app.errorsData)))
rootElement = doc.getDocumentElement()
return rootElement
def checkResponseBody(inStream):
docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder()
source = InputSource()
source.setByteStream(inStream)
doc = docBuilder.parse(source)
tag = "SAIL_Error"
nodeList = doc.getElementsByTagName(tag)
count = nodeList.getLength()
if (count < 1):
fatal("response did not contain a '" + tag + "' tag: " + responseBody)
if (count > 1):
fatal("response contained multiple '" + tag + "' tags: " +
responseBody)
node = nodeList.item(0)
id = node.getAttribute("ID")
if (id != "AC_OK"):
msg = node.getAttribute("Msg")
fatal("from IHS Admin Server: " + msg)
def startElement(self, namespaceURI, lname, qname, attrs):
if (namespaceURI == "http://www.w3.org/2002/xforms"
and lname == "submission" and self.state == 1):
#вставка биндов для правил в mainModel
stream = FileInputStream(self.bindPath)
self.parser.parse(InputSource(stream))
self.state = 2
self.xmlWriter.writeStartElement(qname)
for i in range(0, attrs.getLength()):
self.xmlWriter.writeAttribute(attrs.getQName(i), attrs.getValue(i))
if (attrs.getValue(attrs.getIndex("class")) == "rule"):
#вставка блока с правилами в div с классом "rule"
stream = FileInputStream(self.rulePath)
self.parser.parse(InputSource(stream))
if (namespaceURI == "http://www.w3.org/2002/xforms" and lname == "model" \
and attrs.getValue(attrs.getIndex("id")) == "xformId_mainModel"):
#вставка биндов для правил в mainModel
self.state = 1
def _empty_source(self, *args):
name, publicId, baseURI, systemId = args
source = InputSource()
byte_stream = ByteArrayInputStream(array([], "b"))
source.setByteStream(byte_stream)
source.setPublicId(publicId)
source.setSystemId(systemId)
return source
def readFileSAX(filename):
try:
FIS = FileInputStream(File(filename))
ISR = InputStreamReader(FIS, ENCODING)
src = InputSource(ISR, encoding=ENCODING)
factory = SAXParserFactory.newInstance()
factory.setValidating(1)
parser = factory.newSAXParser()
parser.parse(src, SAXhandler())
except:
print '\nError: %s\nvalue: %s' % sys.exc_info()[:2]
def load(self, filename, language):
parser = XMLReaderFactory.createXMLReader()
#if (filename.endsWith(".gz")):
#input_src = InputSource(GZipInputStream(FileInputStream(filename)))
#else:
input_src = InputSource(filename)
parser.contentHandler = ParseHandler(language)
parser.parse(input_src)
HibernateUtil.commitTransaction()
HibernateUtil.closeSession()
def uploadXML(self, action="ui"):
'''
функция реализует загрузку данных из xml в базу данных
'''
parser = XMLReaderFactory.createXMLReader()
handler = UploadXMLHandler(self.tableInstance, action)
parser.setContentHandler(handler)
parser.setErrorHandler(handler)
parser.setFeature("http://xml.org/sax/features/namespace-prefixes",
True)
parser.setProperty("http://xml.org/sax/properties/lexical-handler",
handler)
parser.parse(InputSource(self.dataStream))
def tiltCallback(self, topic, message):
tiltEvent = {'name': 'Motion/Tilt/MotionStatus'}
try:
builder = DocumentBuilderFactory.newInstance().newDocumentBuilder()
topnode = builder.parse(InputSource(StringReader((
message.toString())))).getFirstChild()
assert topnode.getNodeName() == 'Payload'
nodes1lev = topnode.getChildNodes()
for i in xrange(nodes1lev.getLength()):
node1 = nodes1lev.item(i)
assert node1.getNodeName() == 'Parameter'
atts = node1.getAttributes()
tiltEvent[atts.item(0).getNodeValue()] = node1.getTextContent()
except Exception, e:
print "Error in SenSafety/mqtt xml format, " + str(e)
def resolveEntity(self, name, publicId, baseURI, systemId):
logger.debug("XMLExternalEntityResolver resolveEntity, name : ", name,
", publicId: ", publicId, ", baseURI: ", baseURI,
", systemId: ", systemId)
try:
filename = systemId
logger.debug('resolveEntity, file name: ', filename, ", path: ",
self.remotePath)
strContent = String(
self.fileMonitor.getFileContent(self.remotePath +
self.fsSeparator + filename))
return InputSource(ByteArrayInputStream(strContent.getBytes()))
except Exception, ex:
logger.debug("XMLExternalEntityResolver Exception: ", ex)
def __readWsdlWithIBMFactory(wsdlData, importWsdlDocuments=1):
if wsdlData == None:
raise WSDLException('WSDL Content is Null')
else:
from com.ibm.wsdl.factory import WSDLFactoryImpl
wsdlfactoryIdox = WSDLFactoryImpl()
reader = wsdlfactoryIdox.newWSDLReader()
if importWsdlDocuments == 1:
reader.setFeature('javax.wsdl.importDocuments', Boolean.TRUE)
else:
reader.setFeature('javax.wsdl.importDocuments', Boolean.FALSE)
wsdlData = String(wsdlData.strip())
arr = wsdlData.getBytes()
stream = ByteArrayInputStream(arr)
inSrc = InputSource(stream)
defintion = reader.readWSDL(None, inSrc)
return defintion
def findXpathNodes(self, xmlAsText, xpathExpr):
xmlText = InputSource(
ByteArrayInputStream(lang.String(xmlAsText).getBytes()))
docBuilderFactory = DocumentBuilderFactory.newInstance()
docBuilderFactory.setValidating(0)
docBuilderFactory.setNamespaceAware(0)
docBuilder = docBuilderFactory.newDocumentBuilder()
doc = docBuilder.parse(xmlText)
xpathFactory = XPathFactory.newInstance()
xPath = xpathFactory.newXPath()
expr = xPath.compile(xpathExpr)
nodeList = expr.evaluate(doc, XPathConstants.NODESET)
nodeCount = nodeList.getLength()
count = 0
xpathNodes = []
while count < nodeCount:
xpathNodes.append(nodeList.item(count))
count = count + 1
return xpathNodes
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 _parse_from_source(self, source):
from com.indelv.dom.util import XMLReader
from org.xml.sax import InputSource
return Document(XMLReader.parseDocument(InputSource(source)))
def buildDocumentString(self, string):
from java.io import StringReader
from org.xml.sax import InputSource
return self._parse_from_source(InputSource(StringReader(string)))
def resolveEntity(self, publicId, systemId):
return InputSource(
ClassLoader.getSystemResourceAsStream("dtds/" +
os.path.split(systemId)[1]))
def loadXMLFromString(xml): db = DocumentBuilderFactory.newInstance().newDocumentBuilder() inputSource = InputSource(StringReader(xml)); return(db.parse(inputSource))
class XMLEventHandler(DefaultHandler2):
def __init__(self, parser):
self.parser = parser
self._tags = {}
self.not_in_dtd = True
self._entity = {}
self._previous_event = None
# --- Helpers -------------------------------------------------------------
def _intern(self, tag):
return self._tags.setdefault(tag, tag)
def _qualify(self, local_name, qname, namespace=None):
namespace_separator = self.parser.namespace_separator
if namespace_separator is None:
return qname
if not namespace:
return local_name
else:
return namespace + namespace_separator + local_name
def _char_slice_to_unicode(self, characters, start, length):
"""Convert a char[] slice to a PyUnicode instance"""
text = Py.newUnicode(String(characters[start:start + length]))
return text
def _expat_content_model(self, name, model_):
# TODO : implement a model parser
return (name, model_) # does not fit expat conventions
def _update_location(self, event=None):
parser = self.parser
locator = self._locator
# ugly hack that takes care of a xerces-specific (?) locator issue:
# locate start and end elements at the '<' instead of the first tag
# type character.
if event == "startElement" and self._previous_event == "characters":
parser._NextColumnNumber = max(parser._NextColumnNumber - 1, 0)
if event == "endElement" and self._previous_event == "characters":
parser._NextColumnNumber = max(parser._NextColumnNumber - 2, 0)
# TODO: use the same trick to report accurate error locations ?
parser.CurrentLineNumber = parser._NextLineNumber
parser.CurrentColumnNumber = parser._NextColumnNumber
parser._NextLineNumber = locator.getLineNumber()
parser._NextColumnNumber = locator.getColumnNumber() - 1
self._previous_event = event
# --- ContentHandler Interface --------------------------------------------
@expat("ProcessingInstructionHandler")
def processingInstruction(self, target, data):
return target, data
@expat("StartElementHandler")
def startElement(self, namespace, local_name, qname, attributes):
tag = self._qualify(local_name, qname, namespace)
attribs = {}
length = attributes.getLength()
for index in range(length):
local_name = attributes.getLocalName(index)
qname = attributes.getQName(index)
namespace = attributes.getURI(index)
name = self._qualify(local_name, qname, namespace)
value = attributes.getValue(index)
attribs[name] = value
return self._intern(tag), attribs
@expat("EndElementHandler")
def endElement(self, namespace, local_name, qname):
return self._intern(self._qualify(local_name, qname, namespace))
@expat("CharacterDataHandler")
def characters(self, characters, start, length):
return self._char_slice_to_unicode(characters, start, length)
@expat("DefaultHandlerExpand")
def characters(self, characters, start, length):
return self._char_slice_to_unicode(characters, start, length)
@expat("DefaultHandler")
def characters(self, characters, start, length):
# TODO: make a helper function here
if self._entity["location"] == (self.parser.CurrentLineNumber,
self.parser.CurrentColumnNumber):
return "&%s;" % self._entity["name"]
else:
return self._char_slice_to_unicode(characters, start, length)
@expat("StartNamespaceDeclHandler")
def startPrefixMapping(self, prefix, uri):
return prefix, uri
@expat("EndNamespaceDeclHandler")
def endPrefixMapping(self, prefix):
return prefix
empty_source = InputSource(ByteArrayInputStream(array([], "b")))
@expat("ExternalEntityRefHandler",
guard="not_in_dtd",
returns=empty_source)
def resolveEntity(self, name, publicId, baseURI, systemId):
context = name # wrong. see expat headers documentation.
base = self.parser.GetBase()
return context, base, systemId, publicId
@expat("DefaultHandlerExpand", guard="not_in_dtd", returns=empty_source)
def resolveEntity(self, name, publicId, baseURI, systemId):
return "&%s;" % name
@expat("DefaultHandler", guard="not_in_dtd", returns=empty_source)
def resolveEntity(self, name, publicId, baseURI, systemId):
return "&%s;" % name
@expat(force=True, returns=empty_source)
def resolveEntity(self, name, publicId, baseURI, systemId):
pass
def setDocumentLocator(self, locator):
self._locator = locator
def skippedEntity(self, name):
error = ExpatError()
error.lineno = self.ErrorLineNumber = self.parser._NextLineNumber
error.offset = self.ErrorColumnNumber = self.parser._NextColumnNumber
error.code = self.ErrorCode = None
message = "undefined entity &%s;: line %s, column %s"
message = message % (name, error.lineno, error.offset)
error.__init__(message)
raise error
# --- LexicalHandler Interface --------------------------------------------
@expat("CommentHandler")
def comment(self, characters, start, length):
return self._char_slice_to_unicode(characters, start, length)
@expat("StartCdataSectionHandler")
def startCDATA(self):
return ()
@expat("EndCdataSectionHandler")
def endCDATA(self):
return ()
@expat("StartDoctypeDeclHandler", force=True)
def startDTD(self, name, publicId, systemId):
self.not_in_dtd = False
has_internal_subset = 0 # don't know this ...
return name, systemId, publicId, has_internal_subset
@expat("EndDoctypeDeclHandler", force=True)
def endDTD(self):
self.not_in_dtd = True
def startEntity(self, name):
self._entity = {}
self._entity["location"] = (self.parser._NextLineNumber,
self.parser._NextColumnNumber)
self._entity["name"] = name
def endEntity(self, name):
pass
# --- DTDHandler Interface ------------------------------------------------
@expat("NotationDeclHandler")
def notationDecl(self, name, publicId, systemId):
base = self.parser.GetBase()
return name, base, systemId, publicId
@expat("UnparsedEntityDeclHandler") # deprecated
def unparsedEntityDecl(self, name, publicId, systemId, notationName):
base = self.parser.GetBase()
return name, base, systemId, publicId, notationName
# --- DeclHandler Interface -----------------------------------------------
@expat("AttlistDeclHandler")
def attributeDecl(self, eName, aName, type, mode, value):
# TODO: adapt mode, required, etc.
required = False
return eName, aName, type, value, required
@expat("ElementDeclHandler")
def elementDecl(self, name, model):
return self._expat_content_model(name, model)
@expat("EntityDeclHandler")
def externalEntityDecl(self, name, publicId, systemId):
base = self.parser.GetBase()
value = None
is_parameter_entity = None
notation_name = None
return (name, is_parameter_entity, value, base, systemId, publicId,
notation_name)
@expat("EntityDeclHandler")
def internalEntityDecl(self, name, value):
base = self.parser.GetBase()
is_parameter_entity = None
notation_name = None
systemId, publicId = None, None
return (name, is_parameter_entity, value, base, systemId, publicId,
notation_name)
sys.path.append(os.getcwd()) # in PyCharm this fixes import errors
from javax.xml.xpath import *
from net.sf.saxon.s9api import *
from org.xml.sax import InputSource
from javax.xml.transform.sax import SAXSource
from java.lang import System
from net.sf.saxon.xpath import *
from bottle import route, run, request, error, app
xpf = XPathFactoryImpl()
xpe = xpf.newXPath()
System.err.println("Loaded XPath Provider " + xpe.getClass().getName())
input_s = InputSource("input.xml")
sax_source = SAXSource(input_s)
doc = xpe.setSource(sax_source)
template = """
<html>
<body>
Search Books:
<form action='/' method='GET'>
<input type='text' name='title' size=50 value="%s">
<select name="type">
<option value="*">All</option>
<option value="books">Books</option>
<option value="videos">Videos</option>
</select>
<select name="rent_days">
