1

#

     2

# minixsv, Release 0.3

     3

# file: pyxsval.py

     4

#

     5

# API for XML schema validator

     6

#

     7

# history:

     8

# 2004-09-09 rl   created

     9

# 2004-09-29 rl   adapted to re-designed XML interface classes,

    10

#                 ErrorHandler separated, URL processing added, some bugs fixed

    11

# 2004-10-07 rl   Validator classes extracted into separate files

    12

# 2004-10-12 rl   API re-worked, XML text processing added

    13

#

    14

# Copyright (c) 2004 by Roland Leuthe.  All rights reserved.

    15

#

    16

# --------------------------------------------------------------------

    17

# The minixsv XML schema validator is

    18

#

    19

# Copyright (c) 2004 by Roland Leuthe

    20

#

    21

# By obtaining, using, and/or copying this software and/or its

    22

# associated documentation, you agree that you have read, understood,

    23

# and will comply with the following terms and conditions:

    24

#

    25

# Permission to use, copy, modify, and distribute this software and

    26

# its associated documentation for any purpose and without fee is

    27

# hereby granted, provided that the above copyright notice appears in

    28

# all copies, and that both that copyright notice and this permission

    29

# notice appear in supporting documentation, and that the name of

    30

# the author not be used in advertising or publicity

    31

# pertaining to distribution of the software without specific, written

    32

# prior permission.

    33

#

    34

# THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

    35

# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-

    36

# ABILITY AND FITNESS.  IN NO EVENT SHALL THE AUTHOR

    37

# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY

    38

# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

    39

# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS

    40

# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

    41

# OF THIS SOFTWARE.

    42

# --------------------------------------------------------------------

    43

    44

__all__ = [

    45

    # public symbols

    46

    "parseAndValidate",

    47

    "parseAndValidateString",

    48

    "parseAndValidateXmlInput",

    49

    "parseAndValidateXmlInputString",

    50

    "parseAndValidateXmlSchema",

    51

    "parseAndValidateXmlSchemaString",

    52

    "XsValidator",

    53

    "XMLIF_MINIDOM",

    54

    "XMLIF_ELEMENTTREE"

    55

    ]

    56

    57

    58

from xsvalErrorHandler import *

    59

from xsvalBase import XsValBase

    60

from xsvalSchema import XsValSchema

    61

    62

    63

XMLIF_MINIDOM     = "XMLIF_MINIDOM"

    64

XMLIF_ELEMENTTREE = "XMLIF_ELEMENTTREE"

    65

    66

    67

_XS_VAL_DEFAULT_ERROR_LIMIT = 20

    68

    69

_OWNDIR = os.path.dirname(__file__)

    70

    71

    72

########################################

    73

# convenience function for validating 

    74

# 1. XML schema file

    75

# 2. XML input file

    76

# If xsdFile is specified, it will be used for validation

    77

# If xsdFile=None, the schemaLocation attribute is expected in the root tag of the XML input file

    78

#

    79

def parseAndValidate (inputFile, xsdFile=None, **kw):

    80

    return parseAndValidateXmlInput (inputFile, xsdFile, 1, **kw)

    81

    82

    83

########################################

    84

# convenience function for validating 

    85

# 1. text string containing the XML schema

    86

# 2. text string containing the XML input

    87

# If xsdText is given, it will be used for validation

    88

# If xsdText=None, the schemaLocation attribute is expected in the root tag of the XML input

    89

#

    90

def parseAndValidateString (inputText, xsdText=None, **kw):

    91

    return parseAndValidateXmlInputString (inputText, xsdText, 1, **kw)

    92

    93

    94

########################################

    95

# factory for validating 

    96

# 1. XML schema file (only if validateSchema=1)

    97

# 2. XML input file

    98

# If xsdFile is specified, it will be used for validation

    99

# If xsdFile=None, the schemaLocation attribute is expected in the root tag of the XML input file

   100

#

   101

def parseAndValidateXmlInput (inputFile, xsdFile=None, validateSchema=0, **kw):

   102

    xsValidator = XsValidator (**kw)

   103

    # parse XML input file

   104

    inputTreeWrapper = xsValidator.parse (inputFile)

   105

    # validate XML input file

   106

    return xsValidator.validateXmlInput (inputFile, inputTreeWrapper, xsdFile, validateSchema)

   107

   108

   109

########################################

   110

# factory for validating 

   111

# 1. text string containing the XML schema (only if validateSchema=1)

   112

# 2. text string containing the XML input

   113

# If xsdText is given, it will be used for validation

   114

# If xsdText=None, the schemaLocation attribute is expected in the root tag of the XML input

   115

#

   116

def parseAndValidateXmlInputString (inputText, xsdText=None, validateSchema=0, **kw):

   117

    xsValidator = XsValidator (**kw)

   118

    # parse XML input text string

   119

    inputTreeWrapper = xsValidator.parseString (inputText)

   120

    # validate XML input text string

   121

    return xsValidator.validateXmlInputString (inputTreeWrapper, xsdText, validateSchema)

   122

   123

   124

########################################

   125

# factory for validating only given XML schema file

   126

#

   127

def parseAndValidateXmlSchema (xsdFile, **kw):

   128

    xsValidator = XsValidator (**kw)

   129

    # parse XML schema file

   130

    xsdTreeWrapper = xsValidator.parse (xsdFile)

   131

    # validate XML schema file

   132

    return xsValidator.validateXmlSchema (xsdFile, xsdTreeWrapper)

   133

   134

   135

########################################

   136

# factory for validating only given XML schema file

   137

#

   138

def parseAndValidateXmlSchemaString (xsdText, **kw):

   139

    xsValidator = XsValidator (**kw)

   140

    # parse XML schema

   141

    xsdTreeWrapper = xsValidator.parseString (xsdText)

   142

    # validate XML schema

   143

    return xsValidator.validateXmlSchema ("", xsdTreeWrapper)

   144

   145

   146

########################################

   147

# XML schema validator class

   148

#

   149

class XsValidator:

   150

    def __init__(self, xmlIfClass=XMLIF_MINIDOM,

   151

                 warningProc=IGNORE_WARNINGS, errorLimit=_XS_VAL_DEFAULT_ERROR_LIMIT, verbose=0):

   152

   153

        self.warningProc   = warningProc

   154

        self.errorLimit    = errorLimit

   155

        self.verbose       = verbose

   156

   157

        # enable interface to minidom

   158

        if xmlIfClass == XMLIF_MINIDOM:

   159

            import minidomif

   160

            self.xmlIf = minidomif.MiniDomInterface(verbose)

   161

   162

        # enable interface to elementtree

   163

        elif xmlIfClass == XMLIF_ELEMENTTREE:

   164

            import elemtreeif

   165

            self.xmlIf = elemtreeif.ElementTreeInterface(verbose)

   166

   167

        # create error handler

   168

        self.errorHandler  = ErrorHandler (errorLimit, warningProc, verbose)

   169

   170

   171

    ########################################

   172

    # parse XML file

   173

    # 'file' may be a filepath or an URI

   174

    #

   175

    def parse (self, file, baseUrl=""):

   176

        try:

   177

            self._verbosePrint ("Parsing %s..." %(file))

   178

            treeWrapper = self.xmlIf.extParse(file, baseUrl)

   179

        except AssertionError, errstr:

   180

            self.errorHandler.raiseError (errstr)

   181

        return treeWrapper

   182

   183

   184

    ########################################

   185

    # parse text string containing XML 

   186

    #

   187

    def parseString (self, text):

   188

        try:

   189

            self._verbosePrint ("Parsing XML text string...")

   190

            treeWrapper = self.xmlIf.extParseString(text)

   191

        except AssertionError, errstr:

   192

            self.errorHandler.raiseError (errstr)

   193

        return treeWrapper

   194

   195

   196

    ########################################

   197

    # validate XML input

   198

    #

   199

    def validateXmlInput (self, xmlInputFile, inputTreeWrapper, xsdFile=None, validateSchema=0):

   200

        # parse XML schema file

   201

        if xsdFile != None:

   202

            xsdTreeWrapper = self.parse (xsdFile)

   203

        else:

   204

            # a schemaLocation attribute is expected in the root tag of the XML input file

   205

            xsdFile = self._retrieveReferencedXsdFile (inputTreeWrapper)

   206

            xsdTreeWrapper = self.parse (xsdFile, inputTreeWrapper.getRootNode().getAbsUrl())

   207

   208

        return self._validateXmlInput (xmlInputFile, xsdFile, inputTreeWrapper, xsdTreeWrapper, validateSchema)

   209

   210

   211

    ########################################

   212

    # validate XML input

   213

    #

   214

    def validateXmlInputString (self, inputTreeWrapper, xsdText=None, validateSchema=0):

   215

        # parse XML schema file

   216

        if xsdText != None:

   217

            xsdFile = "schema text"

   218

            xsdTreeWrapper = self.parseString (xsdText)

   219

        else:

   220

            # a schemaLocation attribute is expected in the root tag of the XML input file

   221

            xsdFile = self._retrieveReferencedXsdFile (inputTreeWrapper)

   222

            xsdTreeWrapper = self.parse (xsdFile, inputTreeWrapper.getRootNode().getAbsUrl())

   223

   224

        return self._validateXmlInput ("input text", xsdFile, inputTreeWrapper, xsdTreeWrapper, validateSchema)

   225

   226

   227

    ########################################

   228

    # validate XML schema separately

   229

    #

   230

    def validateXmlSchema (self, xsdFile, xsdTreeWrapper):

   231

        # parse minixsv internal schema

   232

        rulesTreeWrapper = self.parse(os.path.join (_OWNDIR, "xsStructs.xsd"))

   233

   234

        self._verbosePrint ("Validating %s..." %(xsdFile))

   235

        xsvGivenXsdFile = XsValSchema (self.xmlIf, self.errorHandler)

   236

        xsvGivenXsdFile.validate(xsdTreeWrapper, rulesTreeWrapper)

   237

        self.errorHandler.flushOutput()

   238

        return xsdTreeWrapper

   239

   240

   241

    ########################################

   242

    # validate XML input tree and xsd tree if requested

   243

    #

   244

    def _validateXmlInput (self, xmlInputFile, xsdFile, inputTreeWrapper, xsdTreeWrapper, validateSchema=0):

   245

        # validate XML schema file if requested

   246

        if validateSchema:

   247

            self.validateXmlSchema (xsdFile, xsdTreeWrapper)

   248

   249

        try:

   250

            xsdTreeWrapper.insertSubtree (xsdTreeWrapper.getRootNode().getFirstChild(), os.path.join (_OWNDIR, "datatypes2.xsd"), None)

   251

        except AssertionError, errstr:

   252

            self.errorHandler.raiseError (errstr)

   253

   254

        self._verbosePrint ("Validating %s..." %(xmlInputFile))

   255

        xsvInputFile = XsValBase (self.xmlIf, self.errorHandler)

   256

        xsvInputFile.validate(inputTreeWrapper, xsdTreeWrapper)

   257

        self.errorHandler.flushOutput()

   258

        return inputTreeWrapper

   259

   260

   261

    ########################################

   262

    # retrieve XML schema location from XML input tree

   263

    #

   264

    def _retrieveReferencedXsdFile (self, inputTreeWrapper):

   265

        # a schemaLocation attribute is expected in the root tag of the XML input file

   266

        for attributeName, attributeValue in inputTreeWrapper.getRootNode().getAttributeDict().items():

   267

            if self.xmlIf.extractLocalName(attributeName) in ("noNamespaceSchemaLocation", "schemaLocation"):

   268

                xsdFile = attributeValue

   269

                return xsdFile

   270

        else:

   271

            self.errorHandler.raiseError ("No schema file specified!")

   272

   273

   274

    ########################################

   275

    # print if verbose flag is set

   276

    #

   277

    def _verbosePrint (self, text):

   278

        if self.verbose:

   279

            print text

   280

   281

   282

   283