1 """Simple API for XML (SAX) implementation for Python.

     2 

     3 This module provides an implementation of the SAX 2 interface;

     4 information about the Java version of the interface can be found at

     5 http://www.megginson.com/SAX/.  The Python version of the interface is

     6 documented at <...>.

     7 

     8 This package contains the following modules:

     9 

    10 handler -- Base classes and constants which define the SAX 2 API for

    11            the 'client-side' of SAX for Python.

    12 

    13 saxutils -- Implementation of the convenience classes commonly used to

    14             work with SAX.

    15 

    16 xmlreader -- Base classes and constants which define the SAX 2 API for

    17              the parsers used with SAX for Python.

    18 

    19 expatreader -- Driver that allows use of the Expat parser with SAX.

    20 """

    21 

    22 from xmlreader import InputSource

    23 from handler import ContentHandler, ErrorHandler

    24 from _exceptions import SAXException, SAXNotRecognizedException, \

    25                         SAXParseException, SAXNotSupportedException, \

    26                         SAXReaderNotAvailable

    27 

    28 

    29 def parse(source, handler, errorHandler=ErrorHandler()):

    30     parser = make_parser()

    31     parser.setContentHandler(handler)

    32     parser.setErrorHandler(errorHandler)

    33     parser.parse(source)

    34 

    35 def parseString(string, handler, errorHandler=ErrorHandler()):

    36     try:

    37         from cStringIO import StringIO

    38     except ImportError:

    39         from StringIO import StringIO

    40 

    41     if errorHandler is None:

    42         errorHandler = ErrorHandler()

    43     parser = make_parser()

    44     parser.setContentHandler(handler)

    45     parser.setErrorHandler(errorHandler)

    46 

    47     inpsrc = InputSource()

    48     inpsrc.setByteStream(StringIO(string))

    49     parser.parse(inpsrc)

    50 

    51 # this is the parser list used by the make_parser function if no

    52 # alternatives are given as parameters to the function

    53 

    54 default_parser_list = ["xml.sax.expatreader"]

    55 

    56 # tell modulefinder that importing sax potentially imports expatreader

    57 _false = 0

    58 if _false:

    59     import xml.sax.expatreader

    60 

    61 import os, sys

    62 if os.environ.has_key("PY_SAX_PARSER"):

    63     default_parser_list = os.environ["PY_SAX_PARSER"].split(",")

    64 del os

    65 

    66 _key = "python.xml.sax.parser"

    67 if sys.platform[:4] == "java" and sys.registry.containsKey(_key):

    68     default_parser_list = sys.registry.getProperty(_key).split(",")

    69 

    70 

    71 def make_parser(parser_list = []):

    72     """Creates and returns a SAX parser.

    73 

    74     Creates the first parser it is able to instantiate of the ones

    75     given in the list created by doing parser_list +

    76     default_parser_list.  The lists must contain the names of Python

    77     modules containing both a SAX parser and a create_parser function."""

    78 

    79     for parser_name in parser_list + default_parser_list:

    80         try:

    81             return _create_parser(parser_name)

    82         except ImportError,e:

    83             import sys

    84             if parser_name in sys.modules:

    85                 # The parser module was found, but importing it

    86                 # failed unexpectedly, pass this exception through

    87                 raise

    88         except SAXReaderNotAvailable:

    89             # The parser module detected that it won't work properly,

    90             # so try the next one

    91             pass

    92 

    93     raise SAXReaderNotAvailable("No parsers found", None)

    94 

    95 # --- Internal utility methods used by make_parser

    96 

    97 if sys.platform[ : 4] == "java":

    98     def _create_parser(parser_name):

    99         from org.python.core import imp

   100         drv_module = imp.importName(parser_name, 0, globals())

   101         return drv_module.create_parser()

   102 

   103 else:

   104     def _create_parser(parser_name):

   105         drv_module = __import__(parser_name,{},{},['create_parser'])

   106         return drv_module.create_parser()

   107 

   108 del sys