CellMLToNektar.validator Namespace Reference

Classes
class	CellMLValidator
class	LxmlRelaxngValidator
class	RvpRelaxngValidator
class	ValidatorError

Functions
def	quit (self)
	def del(self): """ Tell our RVP process to quit. More...
def	validate (self, stream)
def	get_validation_errors (self)
def	_error_found (self, line, col, msg)
def	_start_tag_open (self, cur, name)
def	_attribute (self, cur, name, val)
def	_start_tag_close (self, cur, name)
def	_end_tag (self, cur, name)
def	_textonly (self, cur, text)
def	_mixed (self, cur, text)
def	_start (self, grammar='0')
def	_send (self, s)
def	_recv (self)
def	_resp (self)
def	_flush_text (self)
def	_start_element (self, name, attrs)
def	_end_element (self, name)
def	_characters (self, data)
def	check_repo (repo_dir='../../models/all_from_repository', model_suffix='xml', invalid_if_warnings=False, compare=True)
	Convenience functions #. More...
def	compare_output_files (new_stream, old_filename)
def	get_options (args)
	For running as an executable #. More...
def	run ()

Variables
	pycml_path = os.path.dirname(os.path.realpath(__file__))
list	__version__ = "$Revision: 25790 $"[11:-2]
string	profile_name = '/tmp/pycml-profile-%f-%d' % (time.time(), os.getpid())
	_text
	_error_messages
	_prevcol
	_pat
	_parser
	_errors
	_ismixed

Detailed Description

Copyright (c) 2005-2016, University of Oxford.
All rights reserved.

University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.

This file is part of Chaste.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 * Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.
 * Neither the name of the University of Oxford nor the names of its
   contributors may be used to endorse or promote products derived from this
   software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Function Documentation

_attribute()

def CellMLToNektar.validator._attribute (   self,   cur,   name,   val  )

private

Definition at line 339 of file validator.py.

    def _attribute(self, cur, name, val):
        self._send('attribute '+cur+' '+name+' '+val)
        return self._resp()

_characters()

def CellMLToNektar.validator._characters (   self,   data  )

private

Definition at line 432 of file validator.py.

References CellMLToNektar.validator.check_repo().

    def _characters(self, data):
        self._text = self._text + data

_end_element()

def CellMLToNektar.validator._end_element (   self,   name  )

private

Definition at line 428 of file validator.py.

    def _end_element(self, name):
        self._flush_text()
        self._pat = self._end_tag(self._pat, name)
        self._ismixed = True

_end_tag()

def CellMLToNektar.validator._end_tag (   self,   cur,   name  )

private

Definition at line 345 of file validator.py.

    def _end_tag(self, cur, name):
        self._send('end-tag '+cur+' '+name)
        return self._resp()

_error_found()

def CellMLToNektar.validator._error_found (   self,   line,   col,   msg  )

private

Definition at line 330 of file validator.py.

    def _error_found(self, line, col, msg):
        report = "%d,%d:%s" % (line, col, msg.strip())
        logging.getLogger('validator').error(report)
        self._error_messages.append(report)

_flush_text()

def CellMLToNektar.validator._flush_text (   self )

private

Apparently Expat doesn't concatenate text nodes, so we do it
manually; the CharDataHandler collects the text, and this
method passes it to the validator.

Definition at line 408 of file validator.py.

    def _flush_text(self):
        """
        Apparently Expat doesn't concatenate text nodes, so we do it
        manually; the CharDataHandler collects the text, and this
        method passes it to the validator.
        """
        if self._text:
            if self._ismixed:
                self._pat = self._mixed(self._pat, self._text)
            else:
                self._pat = self._textonly(self._pat, self._text)
            self._text = ''

_mixed()

def CellMLToNektar.validator._mixed (   self,   cur,   text  )

private

In mixed content, whitespace is discarded, and any non-whitespace
is counted as equal.

Definition at line 351 of file validator.py.

    def _mixed(self, cur, text):
        """
        In mixed content, whitespace is discarded, and any non-whitespace
        is counted as equal.
        """
        if self._ws.search(text):
            self._send('mixed '+cur+' .')
            return self._resp()
        else:
            return cur

_recv()

def CellMLToNektar.validator._recv (   self )

private

Receive a zero-terminated response from RVP; drop zero byte.

Definition at line 371 of file validator.py.

    def _recv(self):
        """
        Receive a zero-terminated response from RVP; drop zero byte.
        """
        s = ''
        while True:
            # 16 is a good buffer length for ok responses; errors
            # should be rare
            s = s + os.read(self._rvpout, 16)
            if s[-1] == '\0': break
        return s[:-1]

_resp()

def CellMLToNektar.validator._resp (   self )

private

Get a reply from RVP.
If an error occurs, log the message.
Return the current pattern value.

Definition at line 382 of file validator.py.

    def _resp(self):
        """
        Get a reply from RVP.
        If an error occurs, log the message.
        Return the current pattern value.
        """
        r = self._recv().split(' ', 3)
        if r[0] == 'ok': return r[1]
        if r[0] == 'error':
            self._errors = True
            if r[3] != '': # Only report if we have a message
                line = self._parser.CurrentLineNumber
                col  = self._parser.CurrentColumnNumber
                if line != self._prevline or col != self._prevcol:
                    # One report per file position
                    self._error_found(line, col, r[3])
                    self._prevline, self._prevcol = line, col
            return r[1]
        if r[0] == 'er':
            self._errors = True
            return r[1]
        # Unknown response
        raise self.RvpProtocolError, "unexpected response '"+r[0]+"'"
                    

_send()

def CellMLToNektar.validator._send (   self,   s  )

private

Terminate string with zero, encode in UTF-8 and send to RVP.

Definition at line 366 of file validator.py.

    def _send(self, s):
        """
        Terminate string with zero, encode in UTF-8 and send to RVP.
        """
        os.write(self._rvpin, s.encode('UTF-8') + '\0')

_start()

def CellMLToNektar.validator._start (   self,   grammar = '0'  )

private

Definition at line 361 of file validator.py.

    def _start(self, grammar = '0'):
        self._send('start '+grammar)
        return self._resp()

_start_element()

def CellMLToNektar.validator._start_element (   self,   name,   attrs  )

private

Definition at line 420 of file validator.py.

    def _start_element(self, name, attrs):
        self._ismixed = True
        self._flush_text()
        self._pat = self._start_tag_open(self._pat, name)
        self._ismixed = False
        for n, v in attrs.items():
            self._pat = self._attribute(self._pat, n, v)
        self._pat = self._start_tag_close(self._pat, name)

_start_tag_close()

def CellMLToNektar.validator._start_tag_close (   self,   cur,   name  )

private

Definition at line 342 of file validator.py.

    def _start_tag_close(self, cur, name):
        self._send('start-tag-close '+cur+' '+name)
        return self._resp()

_start_tag_open()

def CellMLToNektar.validator._start_tag_open (   self,   cur,   name  )

private

Definition at line 336 of file validator.py.

    def _start_tag_open(self, cur, name):
        self._send('start-tag-open '+cur+' '+name)
        return self._resp()

_textonly()

def CellMLToNektar.validator._textonly (   self,   cur,   text  )

private

Definition at line 348 of file validator.py.

    def _textonly(self, cur, text):
        self._send('text '+cur+' '+text)
        return self._resp()

check_repo()

def CellMLToNektar.validator.check_repo	(		repo_dir = '../../models/all_from_repository',
			model_suffix = 'xml',
			invalid_if_warnings = False,
			compare = True
	)

Convenience functions #.

Validate every model in the CellML repository, and return a list
of invalid models.

If compare is False, writes errors & warnings to log files in the
same folder as the models, otherwise compares the output to log
files already present, and notes differences.

Displays total run time.

Definition at line 447 of file validator.py.

References CellMLToNektar.validator.compare_output_files().

Referenced by CellMLToNektar.validator._characters().

               compare=True):
    """
    Validate every model in the CellML repository, and return a list
    of invalid models.
    
    If compare is False, writes errors & warnings to log files in the
    same folder as the models, otherwise compares the output to log
    files already present, and notes differences.
    
    Displays total run time.
    """
    def close_log_file(stream, filename):
        stream.close()
        try:
            size = os.path.getsize(filename)
            if size == 0:
                os.remove(filename)
        except OSError:
            pass
    import glob, time, gc
    start_time = time.time()
    v = CellMLValidator()
    invalid = []
    files = glob.glob(repo_dir + '/*.' + model_suffix)
    files.sort()
    for filename in files:
        model = os.path.basename(filename)[:-4]
        fn = os.path.splitext(filename)[0]
        warnfn, errfn = fn + '_warnings.log', fn + '_errors.log'
        if compare:
            warn_stream = StringIO()
            err_stream = StringIO()
        else:
            warn_stream = open(warnfn, 'w')
            err_stream = open(errfn, 'w')
        print "Checking model",model,"at",time.strftime("%X %x"),
        sys.stdout.flush()
        valid = v.validate(filename, error_stream=err_stream,
                           warning_stream=warn_stream,
                           invalid_if_warnings=invalid_if_warnings)
        if not valid:
            print max(1,4 - (5+len(model))//8) * '\t', "X"
        else:
            print
        if compare:
            compare_output_files(warn_stream, warnfn)
            compare_output_files(err_stream, errfn)
        else:
            close_log_file(err_stream, errfn)
            close_log_file(warn_stream, warnfn)
        if not valid:
            invalid.append(model)
        gc.collect()
    elapsed_time = time.time() - start_time
    mins,secs = int(elapsed_time//60), int(elapsed_time%60)
    print len(files),"models checked in",mins,"minutes",secs,"seconds."
    print len(invalid),"invalid"
    v.quit()
    return invalid

compare_output_files()

def CellMLToNektar.validator.compare_output_files	(		new_stream,
			old_filename
	)

Definition at line 507 of file validator.py.

Referenced by CellMLToNektar.validator.check_repo().

def compare_output_files(new_stream, old_filename):
    def save_new_output():
        nfp = open(old_filename + '-new', 'w')
        nfp.write(new_stream.getvalue())
        nfp.close()
    new_stream.seek(0, 2)
    new_len = new_stream.tell()
    try:
        fp = open(old_filename, 'r')
    except IOError:
        if new_len > 0:
            print "Log file", old_filename, "doesn't exist,", \
                  "but we have new output"
            try:
                ofp = open(os.path.join(os.path.dirname(old_filename),
                                        'new'), 'a')
                print >>ofp, "Log file", old_filename, "doesn't exist,", \
                      "but we have new output"
                ofp.close()
            except IOError:
                pass
            save_new_output()
        return
    new_stream.seek(0)
    new_lines = set(new_stream.readlines())
    old_lines = set(fp.readlines())
    if old_lines != new_lines:
        print "Output set differs from log file", old_filename
        print "Lines added:", new_lines - old_lines
        print "Lines removed:", old_lines - new_lines
        try:
            ofp = open(os.path.join(os.path.dirname(old_filename), 'new'), 'a')
            print >>ofp, "Output set differs from log file", old_filename
            print >>ofp, "Lines added:", new_lines - old_lines
            print >>ofp, "Lines removed:", old_lines - new_lines, "\n"
            ofp.close()
        except IOError:
            pass
        save_new_output()
    new_stream.close()
    fp.close()
    return

get_options()

def CellMLToNektar.validator.get_options

(

args

)

For running as an executable #.

get_options(args):
Process our command-line options.

args is a list of options & positional arguments.

Definition at line 554 of file validator.py.

Referenced by CellMLToNektar.validator.run().

def get_options(args):
    """get_options(args):
    Process our command-line options.

    args is a list of options & positional arguments.
    """
    usage = 'usage: %prog [options] <cellml file or URI> ...'
    parser = optparse.OptionParser(version="%%prog %s" % __version__,
                                   usage=usage)
    parser.add_option('-o', dest='outfilename', metavar='OUTFILE',
                      help='write *all* output to OUTFILE (overrides -e and -w)')
    parser.add_option('-e', '--error-file',
                      dest='errfilename', metavar='ERRFILE',
                      default='stderr',
                      help='write errors to ERRFILE [default %default]')
    parser.add_option('-w', '--warning-file',
                      dest='warnfilename', metavar='WARNFILE',
                      default='stderr',
                      help='write warnings to WARNFILE [default %default]')
    parser.add_option('-q', '--quiet',
                      dest='quiet', action='store_true', default=False,
                      help="don't display any output, just set exit status")
    parser.add_option('--no-warnings', '--only-errors',
                      dest='show_warnings', action='store_false',
                      default=True,
                      help="don't display warning messages")
    parser.add_option('-s', '--space-messages',
                      dest='space_errors', action='store_true',
                      default=False,
                      help="print a blank line after every warning/error message")
    parser.add_option('-x', '--xml-context',
                      dest='xml_context', action='store_true', default=False,
                      help="display the MathML tree of any expression with invalid units")
    parser.add_option('-u', '--warn-on-unit-conversions',
                      action='store_true', default=False,
                      help="generate a warning if unit conversions are required")
    parser.add_option('--Wu', '--warn-on-units-errors',
                      action='store_true', default=False,
                      dest='warn_on_units_errors',
                      help="give a warning instead of an error for"
                      " dimensional inconsistencies")
    parser.add_option('-i', '--interactive',
                      action='store_true', default=False,
                      help="use with python -i to enter an interactive session"
                      " after validation")
    parser.add_option('-d', '--debug', action='store_true', default=False,
                      help="output debug info to stderr")
    parser.add_option('--profile', action='store_true', default=False,
                      help="turn on profiling of PyCml")

    options, args = parser.parse_args(args)
    if len(args) < 1:
        parser.error("an input CellML file must be specified")
    return options, args

get_validation_errors()

def CellMLToNektar.validator.get_validation_errors

(

self

)

Return the list of all errors found while validating
the current file.

Definition at line 323 of file validator.py.

    def get_validation_errors(self):
        """
        Return the list of all errors found while validating
        the current file.
        """
        return self._error_messages

quit()

def CellMLToNektar.validator.quit

(

self

)

def del(self): """ Tell our RVP process to quit.

This doesn't work well, since del isn't necessarily called at program exit. Hence, there is a manual quit() method. """ self.quit()

Call this method when the validator is finished with.
It terminates the associated RVP process cleanly.
Failure to do so will probably result in an error when your program exits.

Definition at line 288 of file validator.py.

    def quit(self):
        """Call this method when the validator is finished with.
        It terminates the associated RVP process cleanly.
        Failure to do so will probably result in an error when your program exits.
        """
        self._send('quit')
        return self._resp()

run()

def CellMLToNektar.validator.run

(

)

Definition at line 610 of file validator.py.

References CellMLToNektar.utilities.close_output_stream(), CellMLToNektar.validator.get_options(), and CellMLToNektar.utilities.open_output_stream().

def run():
    # Validate all files specified on the command line
    options, files = get_options(sys.argv[1:])
    validator = CellMLValidator()

    # Open output streams
    if not options.outfilename is None:
        out_s = open_output_stream(options.outfilename)
        err_s = warn_s = out_s
    else:
        out_s  = sys.stdout
        err_s  = open_output_stream(options.errfilename)
        warn_s = open_output_stream(options.warnfilename)

    # Keyword arguments for validator
    kwargs = {'show_warnings': options.show_warnings,
              'warning_stream': warn_s,
              'show_errors': not options.quiet,
              'error_stream': err_s,
              'space_errors': options.space_errors,
              'xml_context': options.xml_context,
              'warn_on_units_errors': options.warn_on_units_errors,
              'check_for_units_conversions': options.warn_on_unit_conversions}
    
    if options.debug:
        formatter = logging.Formatter(fmt="%(name)s %(asctime)s: %(message)s")
        handler = logging.StreamHandler(sys.stderr)
        handler.setFormatter(formatter)
        handler.addFilter(OnlyDebugFilter())
        logging.getLogger().addHandler(handler)
        logging.getLogger().setLevel(logging.DEBUG)
        kwargs['loglevel'] = logging.DEBUG
    
    # Validate files
    result = True
    for f in files:
        if not options.quiet:
            print >>out_s, "Validating file", f, "against CellML 1.0"
        res = validator.validate(f, **kwargs)
        if not options.quiet:
            print >>out_s, "File is%s valid CellML 1.0" % ((' NOT','')[res])
        result = result and res
    
    # Close output streams
    close_output_stream(out_s)
    close_output_stream(err_s)
    close_output_stream(warn_s)

    # Tidy up validator
    validator.quit()

    # Set exit status
    if not options.interactive:
        sys.exit(not result)

validate()

def CellMLToNektar.validator.validate	(		self,
			stream
	)

Validate an XML document, returning a boolean.

stream should be a file-like object containing the document to
be validated.
Returns True iff the document was valid.

Definition at line 296 of file validator.py.

    def validate(self, stream):
        """Validate an XML document, returning a boolean.
        
        stream should be a file-like object containing the document to
        be validated.
        Returns True iff the document was valid.
        """
        # Initialise
        self._text = ''
        self._errors, self._error_messages = False, []
        self._prevline, self._prevcol = -1, -1
        self._pat = self._start()
        # Create parser
        parser = self.expat.ParserCreate(namespace_separator=':')
        parser.StartElementHandler = self._start_element
        parser.EndElementHandler = self._end_element
        parser.CharacterDataHandler = self._characters
        self._parser = parser
        # Parse & validate
        try:
            self._parser.ParseFile(stream)
        except self.expat.ExpatError, e:
            self._errors = True
            self._error_found(e.lineno, e.offset, str(e))
        # Any errors
        return not self._errors

Variable Documentation

__version__

list CellMLToNektar.validator.__version__ = "$Revision: 25790 $"[11:-2]

private

Definition at line 56 of file validator.py.

_error_messages

CellMLToNektar.validator._error_messages

private

Definition at line 305 of file validator.py.

_errors

CellMLToNektar.validator._errors

private

Definition at line 318 of file validator.py.

_ismixed

CellMLToNektar.validator._ismixed

private

Definition at line 421 of file validator.py.

_parser

CellMLToNektar.validator._parser

private

Definition at line 313 of file validator.py.

_pat

CellMLToNektar.validator._pat

private

Definition at line 307 of file validator.py.

_prevcol

CellMLToNektar.validator._prevcol

private

Definition at line 306 of file validator.py.

_text

CellMLToNektar.validator._text

private

Definition at line 304 of file validator.py.

profile_name

string CellMLToNektar.validator.profile_name = '/tmp/pycml-profile-%f-%d' % (time.time(), os.getpid())

Definition at line 669 of file validator.py.

pycml_path

CellMLToNektar.validator.pycml_path = os.path.dirname(os.path.realpath(__file__))

Definition at line 49 of file validator.py.