CellMLToNektar.validator.CellMLValidator Class Reference

Inheritance diagram for CellMLToNektar.validator.CellMLValidator:

Public Member Functions
def	__init__ (self, create_relaxng_validator=True)
def	quit (self)
def	validate (self, source, return_doc=False, assume_valid=False, **kw)

Static Public Member Functions
def	setup_logging (show_errors=True, error_stream=sys.stderr, show_warnings=True, warning_stream=sys.stderr, space_errors=False, loglevel=logging.WARNING, **kwargs)
def	cleanup_logging (handlers)

Public Attributes
	relaxng_validator

Detailed Description

Definition at line 69 of file validator.py.

Constructor & Destructor Documentation

__init__()

def CellMLToNektar.validator.CellMLValidator.__init__	(		self,
			create_relaxng_validator = True
	)

Initialise a validator for CellML files.

Definition at line 70 of file validator.py.

    def __init__(self, create_relaxng_validator=True):
        """Initialise a validator for CellML files."""
        # Create validator from RELAX NG schema
        self.relaxng_validator = None
        if create_relaxng_validator:
            schema_base = os.path.join(pycml_path, 'cellml1.0')
            run_errors = []
            for klass in [LxmlRelaxngValidator, RvpRelaxngValidator]:
                try:
                    self.relaxng_validator = klass(schema_base)
                except ValidatorError, e:
                    run_errors.append(str(e))
                else:
                    break
            if not self.relaxng_validator:
                msg = '\n\t'.join(["Unable to run a RELAX NG validator.  Please install lxml or rvp."]
                                  + run_errors)
                raise ValidatorError(msg)
 

Member Function Documentation

cleanup_logging()

def CellMLToNektar.validator.CellMLValidator.cleanup_logging (   handlers )

static

Flush logger & remove handlers.

Definition at line 136 of file validator.py.

    def cleanup_logging(handlers):
        """Flush logger & remove handlers."""
        logger = logging.getLogger('validator')
        for handler in handlers:
            handler.flush()
            logger.removeHandler(handler)
 

quit()

def CellMLToNektar.validator.CellMLValidator.quit

(

self

)

Since using __del__ is precarious, we provide this method to allow
the RVP process to be killed cleanly.  Call it when the validator
is finished with, or you'll get an interesting error when the program
terminates (if using RVP).

Definition at line 89 of file validator.py.

    def quit(self):
        """
        Since using __del__ is precarious, we provide this method to allow
        the RVP process to be killed cleanly.  Call it when the validator
        is finished with, or you'll get an interesting error when the program
        terminates (if using RVP).
        """
        if self.relaxng_validator:
            self.relaxng_validator.quit()
        return
    

References CellMLToNektar.validator.CellMLValidator.quit(), and CellMLToNektar.validator.CellMLValidator.relaxng_validator.

Referenced by CellMLToNektar.validator.CellMLValidator.quit().

setup_logging()

def CellMLToNektar.validator.CellMLValidator.setup_logging (   show_errors = True,   error_stream = sys.stderr,   show_warnings = True,   warning_stream = sys.stderr,   space_errors = False,   loglevel = logging.WARNING, **  kwargs  )

static

Set up loggers for validation errors/warnings.

Set show_errors or show_warnings to False to suppress the output of
validation error or warning messages, respectively.  When not
suppressed, the messages will be output to the streams given by
error_stream and warning_stream; these should be file-like objects.

If space_errors is True, a blank line will be inserted between
each message.

Definition at line 101 of file validator.py.

                      **kwargs):
        """Set up loggers for validation errors/warnings.
        
        Set show_errors or show_warnings to False to suppress the output of
        validation error or warning messages, respectively.  When not
        suppressed, the messages will be output to the streams given by
        error_stream and warning_stream; these should be file-like objects.
 
        If space_errors is True, a blank line will be inserted between
        each message.
        """
        logger = logging.getLogger('validator')
        logger.setLevel(loglevel)
        if space_errors:
            formatter = logging.Formatter(fmt="%(message)s\n")
        else:
            formatter = logging.Formatter(fmt="%(message)s")
        error_handler = logging.StreamHandler(error_stream)
        error_handler.setLevel(logging.ERROR)
        error_handler.setFormatter(formatter)
        warning_handler = logging.StreamHandler(warning_stream)
        warning_handler.addFilter(OnlyWarningsFilter())
        warning_handler.setFormatter(formatter)
        if not show_errors:
            error_handler.setLevel(logging.CRITICAL)
        if not show_warnings:
            warning_handler.setLevel(logging.CRITICAL)
        logger.addHandler(error_handler)
        logger.addHandler(warning_handler)
        return error_handler, warning_handler
    

validate()

def CellMLToNektar.validator.CellMLValidator.validate	(		self,
			source,
			return_doc = False,
			assume_valid = False,
		**	kw
	)

Validate the given document.

source should be a file-like object, URI, local file name,
or '-' for standard input.  If a file-like object, it must support
the seek method to reset it.

If return_doc is True then the result is a tuple (valid, document),
where if valid==True then document is an Amara binding of the CellML
document.
Otherwise just return True iff the document is valid.

If xml_context is True, then the failing XML tree will be displayed
with every units error.

The assume_valid option allows you to skip RELAX NG validation, along
with many of the checks in the Python code.  This is useful for speeding
transformation of models that are known to pass these checks.

See cellml_model.validate and setup_logging for other keyword arguments.

Definition at line 143 of file validator.py.

    def validate(self, source, return_doc=False, assume_valid=False, **kw):
        """Validate the given document.
 
        source should be a file-like object, URI, local file name,
        or '-' for standard input.  If a file-like object, it must support
        the seek method to reset it.
 
        If return_doc is True then the result is a tuple (valid, document),
        where if valid==True then document is an Amara binding of the CellML
        document.
        Otherwise just return True iff the document is valid.
 
        If xml_context is True, then the failing XML tree will be displayed
        with every units error.
 
        The assume_valid option allows you to skip RELAX NG validation, along
        with many of the checks in the Python code.  This is useful for speeding
        transformation of models that are known to pass these checks.
        
        See cellml_model.validate and setup_logging for other keyword arguments.
        """
        logging_info = CellMLValidator.setup_logging(**kw)
        
        # Validate against RELAX NG schema
        DEBUG('validator', 'CellML Validator version', __version__)
        res = True
        # Get stream of CellML document
        if source == '-':
            stream = sys.stdin
        elif hasattr(source, 'read'):
            stream = source
        elif bt.Uri.IsAbsolute(source):
            stream = bt.Url.UrlOpen(source)
        else:
            if not os.path.isfile(source):
                res = False
                logging.getLogger('validator').error('File ' + source + ' does not exist.')
            else:
                stream = file(source, 'r')
        # Parse & validate
        if res and not assume_valid:
            DEBUG('validator', 'Starting RELAX NG validation')
            res = self.relaxng_validator.validate(stream)
            if stream == source:
                source.seek(0)
            elif not stream == sys.stdin:
                stream.close()
            DEBUG('validator', 'Finished RELAX NG:', res)
 
        # Check further rules that can't be expressed by a (RELAX NG) schema.
        # We use our own Python code for this.
        if res:
            DEBUG('validator', 'Loading model with Amara')
            doc = amara_parse_cellml(source)
            DEBUG('validator', 'Validating loaded model')
            res = doc.model.validate(assume_valid=assume_valid, **kw)
            DEBUG('validator', 'Validation complete:', res)
        else:
            doc = None
 
        # Flush logger & remove handlers
        CellMLValidator.cleanup_logging(logging_info)
 
        # Return result
        if return_doc:
            return (res, doc)
        else:
            if doc:
                doc.model.clean_up()
            return res
 
 

References CellMLToNektar.pycml.amara_parse_cellml(), CellMLToNektar.utilities.DEBUG(), CellMLToNektar.validator.CellMLValidator.relaxng_validator, and CellMLToNektar.validator.CellMLValidator.validate().

Referenced by CellMLToNektar.validator.CellMLValidator.validate().

Member Data Documentation

relaxng_validator

CellMLToNektar.validator.CellMLValidator.relaxng_validator

Definition at line 73 of file validator.py.

Referenced by CellMLToNektar.validator.CellMLValidator.quit(), and CellMLToNektar.validator.CellMLValidator.validate().