def test_binary_file(self):
     # If the source is a binary file-like object, use it as a byte
     # stream.
     prep = prepare_input_source(self.make_byte_stream())
     self.assertIsNone(prep.getCharacterStream())
     self.checkContent(prep.getByteStream(),
                       b"This is a byte stream.")

 def parse(self, source):
     """Parse an XML document from a URL or an InputSource."""
     source = saxutils.prepare_input_source(source)
     self._source = source
     self.reset()
     self._cont_handler.setDocumentLocator(ExpatLocator(self))
     xmlreader.IncrementalParser.parse(self, source)

    def external_entity_ref(self, context, base, sysid, pubid):
        """Add external entity reference to XML document."""
        if not self._external_ges:
            return 1

        source = self._ent_handler.resolveEntity(pubid, sysid)
        source = saxutils.prepare_input_source(source,
                                               self._source.getSystemId() or
                                               "")

        # If an entry does not exist in the xml cache, create it.
        filepath = os.path.join(XML_CACHE, base64.urlsafe_b64encode(pubid))
        if not os.path.isfile(filepath):
            with open(filepath, 'w') as f:
                contents = source.getByteStream().read()
                source.setByteStream(StringIO(contents))
                f.write(contents)

        self._entity_stack.append((self._parser, self._source))
        self._parser = self._parser.ExternalEntityParserCreate(context)
        self._source = source

        try:
            xmlreader.IncrementalParser.parse(self, source)
        except:
            return 0  # FIXME: save error info here?

        (self._parser, self._source) = self._entity_stack[-1]
        del self._entity_stack[-1]
        return 1

 def test_text_file(self):
     # If the source is a text file-like object, use it as a character
     # stream.
     prep = prepare_input_source(self.make_character_stream())
     self.assertIsNone(prep.getByteStream())
     self.checkContent(prep.getCharacterStream(),
                       "This is a character stream.")

def documentFromURI(uri,fragID=None,targetLocalName=None,idAttr=None):
  if type(uri)==types.UnicodeType:
    uri=uri.encode('utf_8')
  source = prepare_input_source(uri)
  doc = documentFromSource(source,fragID,targetLocalName,idAttr)
  # who closes the input?
  return doc

 def parse(self, source):
     "Parse an XML document from a URL or an InputSource."
     self._source = saxutils.prepare_input_source(source)
     try:
         self._parser.parse(source)
     except SAXException, e:
         raise _exceptions.SAXException("", e)

def prepare_input_source(source):
    """given a URL, returns a xml.sax.xmlreader.InputSource

    Works like xml.sax.saxutils.prepare_input_source.  Wraps the
    InputSource in a ReseekFile if the URL returns a non-seekable
    file.

    To turn the buffer off if that happens, you'll need to do
    something like

    f = source.getCharacterStream()
     ...
    try:
       f.nobuffer()
    except AttributeError:
       pass

    or

    if isinstance(f, ReseekFile):
      f.nobuffer()
    
    """
    from xml.sax import saxutils
    source = saxutils.prepare_input_source(source)
    # Is this correct?  Don't know - don't have Unicode experience
    f = source.getCharacterStream() or source.getByteStream()
    try:
        f.tell()
    except (AttributeError, IOError):
        f = ReseekFile.ReseekFile(f)
        source.setByteStream(f)
        source.setCharacterStream(None)
    return source

def test_locator_sax(tester):
    tester.startTest("SAX InputSource")
    parser = CreateParser()
    parser.setContentHandler(LocatorTester(tester, CONTENT_PATH))
    parser.parse(prepare_input_source(CONTENT_PATH))
    verify_finished_locator(tester, parser)
    tester.testDone()
    return

 def test_system_id(self):
     # If the source is an InputSource that has neither a character
     # stream nor a byte stream, open the system ID.
     src = InputSource(self.file)
     prep = prepare_input_source(src)
     self.assertIsNone(prep.getCharacterStream())
     self.checkContent(prep.getByteStream(),
                       b"This was read from a file.")

 def test_character_stream(self):
     # If the source is an InputSource with a character stream, use it.
     src = InputSource(self.file)
     src.setCharacterStream(self.make_character_stream())
     prep = prepare_input_source(src)
     self.assertIsNone(prep.getByteStream())
     self.checkContent(prep.getCharacterStream(),
                       "This is a character stream.")

def test_xmlreader_sax(tester):
    tester.startTest("SAX InputSource")
    parser = CreateParser()
    builder = DomBuilder()
    parser.setContentHandler(builder)
    parser.parse(prepare_input_source(CONTENT_PATH))
    tester.compare(XMLREADER_CONTENT, builder, func=compare_builder)
    tester.testDone()
    return

 def test_byte_stream(self):
     # If the source is an InputSource that does not have a character
     # stream but does have a byte stream, use the byte stream.
     src = InputSource(self.file)
     src.setByteStream(self.make_byte_stream())
     prep = prepare_input_source(src)
     self.assertIsNone(prep.getCharacterStream())
     self.checkContent(prep.getByteStream(),
                       b"This is a byte stream.")

    def parse(self, source):
        source = prepare_input_source(source)

        self.prepareParser(source)
        file = source.getByteStream()
        buffer = file.read(self._bufsize)
        while buffer != "":
            self.feed(buffer)
            buffer = file.read(self._bufsize)
        self.close()

 def _parse_to_queue(self, stream, queue):
     parser = self.rdflib_parser()
     store = _QueueGraph(queue)
     source = prepare_input_source(stream)
     try:
         parser.parse(source, store,
                      *self.parser_args, **self.parser_kwargs)
     except:
         queue.put(('exception', sys.exc_info()))
     else:
         queue.put(('sentinel', None)) # Sentinel

 def fromStream(self, stream, ownerDoc=None):
     self.handler.initState(ownerDoc=ownerDoc)
     #self.parser.parseFile(stream)
     s = saxutils.prepare_input_source(stream)
     self.parser.parse(s)
     rt = self.handler.getRootNode()
     #if hasattr(self.parser.parser,'deref'):
     #    self.parser.parser.deref()
     #self.parser.parser = None
     #self.parser = None
     #self.handler = None
     return rt

def produce_items (input, produce):
	source = prepare_input_source (input)

	parser = xml.sax.make_parser ()
	parser.setFeature (xml.sax.handler.feature_namespaces, 1)
	parser.setContentHandler (OnixHandler (parser, process_item))
	url_cache_dir = os.getenv ("URL_CACHE_DIR")
	if url_cache_dir:
		sys.stderr.write ("using url cache in %s\n" % url_cache_dir)
		parser.setEntityResolver (CachingEntityResolver (parser, url_cache_dir))
	else:
		sys.stderr.write ("no url_cache_dir; XML resources will always be loaded from network\n")
	parser.setErrorHandler (TestErrorHandler ())
	parser.parse (source)

    def parse(self, source):
        try:
            self.__parsing = 1

            # interpret source
            
            source = prepare_input_source(source)

            # create parser
                
            if self.__validate:
                parser = xmlval.XMLValidator()
            else:
                parser = xmlproc.XMLProcessor()

            # set handlers
                
            if self._cont_handler != None or self._lex_handler != None:
                if self._cont_handler == None:
                    self._cont_handler = saxlib.ContentHandler()
                if self._lex_handler == None:
                    self._lex_handler = saxlib.LexicalHandler()

                if self.__namespaces:
                    filter = NamespaceFilter(parser, self._cont_handler,
                                             self._lex_handler, self)
                    parser.set_application(filter)
                else:
                    parser.set_application(self)

            if self._err_handler != None:
                parser.set_error_handler(self)

            if self._decl_handler != None or self._dtd_handler != None:
                parser.set_dtd_listener(self)
                
            # FIXME: set other handlers

            bufsize=16384
            self._parser = parser # make it available for callbacks
            #parser.parse_resource(source.getSystemId()) # FIXME: rest!
            parser.set_sysid(source.getSystemId())
            parser.read_from(source.getByteStream(), bufsize)
            source.getByteStream().close()
            parser.flush()
            parser.parseEnd()
            
        finally:
            self._parser = None
            self.__parsing = 0

    def parse(self, source):
        "Parse an XML document from a URL or an InputSource."
        source = saxutils.prepare_input_source(source)

        self._source = source
        try:
            self.reset()
            self._cont_handler.setDocumentLocator(ExpatLocator(self))
            xmlreader.IncrementalParser.parse(self, source)
        except:
            # bpo-30264: Close the source on error to not leak resources:
            # xml.sax.parse() doesn't give access to the underlying parser
            # to the caller
            self._close_source()
            raise

 def external_entity_ref(self, context, base, sysid, pubid):
     if not self._external_ges:
         return 1
     source = self._ent_handler.resolveEntity(pubid, sysid)
     source = saxutils.prepare_input_source(source, self._source.getSystemId() or '')
     self._entity_stack.append((self._parser, self._source))
     self._parser = self._parser.ExternalEntityParserCreate(context)
     self._source = source
     try:
         xmlreader.IncrementalParser.parse(self, source)
     except:
         return 0
     (self._parser, self._source) = self._entity_stack[-1]
     del self._entity_stack[-1]
     return 1

    def parse(self, source):
        "Parse an XML document from a URL or an InputSource."
        source = saxutils.prepare_input_source(source)

        self._source = source
        self.reset()
        self._cont_handler.setDocumentLocator(ExpatLocator(self))
        try:
            xmlreader.IncrementalParser.parse(self, source)
        finally:
            # Drop reference to Expat parser, but read potential
            # error state before that. Also, if close has completed,
            # we don't have a parser anymore, anyway.
            if self._parser:
                self._ColumnNumber = self._parser.ErrorColumnNumber
                self._LineNumber = self._parser.ErrorLineNumber
                self._parser = None