Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

#FIXED constraint, strings, Attribute values and constraints
#REQUIRED constraint, attributes, Attribute values and constraints
4DOM, Python DOM Offerings, 4DOM: A Full Implementation
document loading, Loading a document using 4DOM
extensions, 4DOM Extensions
4Suite, Python Tools for XML
installation, Installing 4Suite
Python tools for XML, Python Tools for XML
xml.xpath.Evaluate function, A Path Hosting Script
4XSLT, XSLT Processors
command line tool, Using XSLT from the Command Line

A

abbreviated location paths, Location Paths
action tag, web form, The Web Form
actor attribute, SOAP header, Using SOAP Headers
advantages of XML, Key Advantages of XML–International Language Support
hierarchical structure, Hierarchical Structure
APIs (application programming interfaces)
callback-based, Understanding SAX
DOM, The SAX and DOM APIs–The SAX and DOM APIs
Python and, Python and XML
SAX, The SAX and DOM APIs–The SAX and DOM APIs, Python SAX API
stream-based, Understanding SAX
XSC, Using the XSC API–The XMLSwitchHandler Server Class
appendChild ( ) method, Adding and Moving Nodes
appendStylesheetUri( ) method, Creating the CGI Script
applications
decoupling systems, Decoupling Application Systems
SAX in, Using SAX in an Application
web
building, Preparing the Web Server
control, Controlling the Application–Controlling the Application
script execution, Ensuring the script’s execution
site logic, Implementing Site Logic–Controlling the Application
structure, The Web Application Structure–Implementing Site Logic
write permissions, Enabling write permission
web
see also web application, Preparing the Web Server
see also sample application, Understanding the Scope
arithmetic operators, XPath, XPath Arithmetic Operators
arrays, SOAP, Compound Types
Article class, web application, The Article class–The Storage class
article.xml file, Examining NodeList Members
ArticleHandler class, Writing a Simple Handler
ArticleManager class, The ArticleManager class–Controlling the Application
articles, reading (SAX), Reading an Article–Using the Additional Information
ASCII (American Standard Code for Information Interchange) character set, The ASCII character set
Attr interface, Attr
attribute-list declarations, XML, XML Definitions
attributeDecl ( ) method, DeclHandler
attributes
constants, Attribute values and constraints
declarations, Attribute Declarations–Attribute values and constraints
DOM, Looking at Attributes
enumerated, Attribute data types
ID attributes, Attribute values and constraints
namespaces, Namespaces in XML
nextSibling, Getting a Node’s Siblings
nodeType, Determining a Node’s Type
previousSibling, Getting a Node’s Siblings
pseudo-attributes, Processing Instructions
quotes around values, Quotes around attribute values
tokenized, Attribute data types
types, Attribute data types
values, Attribute values and constraints
XML, XML Structure in a Nutshell, XML Definitions
defaults, XML Definitions
names, XML Definitions
values, XML Definitions, XML Definitions
xml:lang, Language Identification
xml:space, Whitespace in Character Data
XPath, testing, Testing Attributes

B

Base server class, Server Core Concepts
BaseHTTPRequestHandler, Using the Server Classes
BaseHTTPServer module, Using the Server Classes
classes, BaseHTTPServer Module Classes
Bill Summary, The BillSummary Example, The BillSummary Example
browser and, Running the Application in a Browser–Running the Application in a Browser
CGI, starting, Starting the CGI
flat file, The Flat File
validation, Conversion and Validation–Creating a validation handler
XML conversion, Conversion and Validation–Creating a validation handler
web form, The Web Form
BillSummary.dtd, The BillSummary Example
binary format, Application Neutrality
binding, DOM, Understanding the DOM
Body element, SOAP, SOAP packet requirements, SOAP Body Elements
BOV (Business Operational View), Business Process and Modeling
bridges, XSLT and, XSLT Processors
browsers
cookies, Baking Cookies for the Server
running Bill Summary, Running the Application in a Browser–Running the Application in a Browser
servers, conversations, HTTP Conversations
business process, ebXML and, Business Process and Modeling
byte arrays, SOAP encoding, SOAP Encoding Rules

C

callback-based APIs, Understanding SAX
Canonical XML, Canonical XML–Canonical XML Structure
carriage-returns, End-of-Line Handling
Cascading StyleSheets (see CSS)
CDATA sections, CDATA Sections
XML, CDATA Sections, XML Definitions
CDATASection instance, Determining a Node’s Type
CDATASection interface, CDATASection
CGI scripts, Preparing the Web Server
Bill Summary, starting, Starting the CGI
BillSumary DTD, The BillSummary Example
failure method, Defining success and error functions
flat file conversion to XML, Converting the flat file to XML
flat2xml.cgi file, The BillSummary Example
flatfile.cgi, Starting the CGI
flatfile.html file, The BillSummary Example
FlatfileParser.py file, The BillSummary Example
success method, Defining success and error functions
ValidityError.py file, The BillSummary Example
web application, The CGI Functionality
profile information, Extracting profile information
profile updating, Updating profile information
XML conversion, validation, Validating the converted XML
XML display, Displaying the XML
XSLT transformation embedding, Creating the CGI Script
character data, Text, Character Data, and Markup
markup and, Text, Character Data, and Markup
whitespace, Whitespace in Character Data–Whitespace in Character Data
XML, XML Definitions
XPath, Getting Character Data
character references, Text, Character Data, and Markup
XML, XML Definitions
CharacterData interface, CharacterData
characters
XML, XML Definitions
XML documents, Characters in XML Documents–UTF-8 Encoding
characters( ) method, ContentHandler
childNodes attribute, nodes, Getting a Node’s Children
class template, pyxml.xml conversion, Class Template
classes
Article, The Article class–The Storage class
ArticleHandler, Writing a Simple Handler
ArticleManager, The ArticleManager class–Controlling the Application
BaseHTTPServer module, BaseHTTPServer Module Classes
DOMImplementation, Building the XML document–Building the XML document
ErrorPrinter, ErrorHandler
Node, Node, Node Constants
ParserFactory, Advanced Parser Factory Usage
PyXMLConversionHandler, The Conversion Handler–The Conversion Handler, Driving the Conversion Handler–Driving the Conversion Handler
SAXException, SAX Exceptions
SAXParseException, Locator
server classes, Using the Server Classes
Storage, The Storage class
StringIO, Converting text to XML
XML Switch, Core XML Switch Classes
XMLMessage, Core XML Switch Classes
XMLMessage classes, The XMLMessage Class–XMLMessage code listing
XMLSwitchHandler, The XML Switch Service
XMLSwitchHandler Server class, The XMLSwitchHandler Server Class–XMLSwitchHandler code architecture
XMLValidator, Creating a validation handler
xsc, Core XML Switch Classes
code
Python
maintenance, The Power of Python and XML
readability, The Power of Python and XML
web application, The Code Architecture
COM
MSXML and, Setting Up MSXML3.0
Python, MSSOAP and, Getting Python COM support
COM objects, ProgID, Setting Up MSXML3.0
command-line
running Python from, Windows
XSLT, Using XSLT from the Command Line
xvcmd.py routine, Validating with the Internal DTD Subset
Comment node, Comment
comment( ) method, LexicalHandler
comments, XML, Comments, XML Definitions
Compile function, XPath, Compiling XPath Expressions
CompleteProfile class, sample application Profiles database, The Complete CustomerProfile Class–The Complete CustomerProfile Class
concat function, XPath, Working with Strings
concatenation, Working with Strings
conditional section, XML, XML Definitions
conformance types, XML, Types of Conformance
connecting web sites, Connecting Web Sites
connections, web services, Connecting to a Web Service
constants
attributes, Attribute values and constraints
Node class, Node Constants
content models, Content models
XML, XML Definitions
content syndication, Python, Web Services, and SOAP
content-related events, The SAX and DOM APIs
ContentHandler interface, SAX, Convenience Functions
ContentHandler object, SAX, ContentHandler
context
XML, XML Definitions
XPath, XPath at a Glance
Context function, XPath, Compiling XPath Expressions
convenience functions, SAX, Convenience Functions
conversations, HTTP, HTTP Conversations
cookies, Baking Cookies for the Server
CORBA IDL, DOM and, Understanding the DOM
Core, DOM, Feature Specifications
count function, XPath, Working with Nodes
createAttribute ( ) method, Document
createAttributeNS( ) method, Document
createCDATASection( ) method, Document
createComment( ) method, Document
createDocument( ) method, DOMImplementation
createDocumentFragement( ) method, Document
createDocumentType( ) method, Converting text to XML, DOMImplementation
createElement( ) method, Converting text to XML, Document
createElementNS( ) method, Document
createEntityReference( ) method, Document
createProcessingInstruction( ) method, Document
createTextNode( ) method, Document
CSS (Cascading Style Sheets), The DOM Specifications, Feature Specifications
defining, XSLT, Defining Stylesheets
Customer table, sample application, Creating a Customer Table
CustomerProfile class, sample application, Building the Profiles Access Class
deleteProfile method, Deleting a profile
insertProfile method, Inserting and Deleting Profiles
interfaces, The Interfaces

D

Data Access Object, sample application and, Understanding the Scope
data models, Canonical XML, The Canonical XML Data Model
data types
SOAP, Simple Types
XML documents, Document Types and Schemas
database, sample application, Understanding the Scope
populating, Populating the Database
declarations
attributes, Attribute Declarations–Attribute values and constraints
element types, Element Type Declarations–Content models
entities, Entity Declarations–Entity Declarations
markup, XML, XML Definitions
notation, XML Definitions
parameter entities, Entity Declarations
process declarations, XML Definitions
XML, XML Structure in a Nutshell, The Document Prolog, XML Definitions
DeclHandler handler, SAX, DTDHandler
DeclHandler object, SAX, Other handler objects
DeclHandler, SAX, DeclHandler
decoupling application systems, Decoupling Application Systems
deleteProfile( ) method, CustomerProfile class, Deleting a profile
descendent nodes, XPath, Testing Descendent Nodes
DHTML (Dynamic HTML), The Document Object Model
dialects, Dialects, Frameworks, and Workflow
disable-output-escaping attribute, xsl:value-of element, Getting the Value of a Node
Discovery and Retrieval phase, ebXML, Phases of ebXML
distributed environments, XML and, Python and XML
distutils, Installing PyXML
doctype object, Document
document entities, Physical Structures
XML, XML Definitions
Document interface, Document
Document Object Model (see DOM)
Document object, MSXML, MSXML3.0 Document Object
methods, MSXML3.0 Document Object Methods
properties, MSXML3.0 Document Object Properties
document objects, DOM, Getting a Document Object
Document Type Declaration
comments, XML Definitions
conditional section, XML Definitions
DTD and, XML Definitions
Document Type Declarations, The Document Prolog
document types, XML, Document Types and Schemas
documentElement object, Document
DocumentFragment object, DocumentFragment
documents, Characters in XML Documents–UTF-8 Encoding
DOM
children, removing, Removing Nodes
editing, Changing Documents
nodes, adding/removing, Adding and Moving Nodes
nodes, new, Creating New Nodes
parents, replacing, Removing Nodes
structural changes, Changing a Document’s Structure
loading
4DOM, Loading a document using 4DOM
minidom, Loading a document using minidom
MSXML, Basic DOM Operations
XML, XML Definitions
data types, Document Types and Schemas
prolog, The Document Prolog
schema valid, Types of Conformance
XLink, Using XLink to Link XML Documents
XPath expressions, XPath at a Glance
DocumentType interface, DocumentType
DOM, The SAX and DOM APIs–The SAX and DOM APIs
4DOM, Python DOM Offerings, 4DOM: A Full Implementation
Attr interface, Attr
attributes and, Looking at Attributes
binding, Understanding the DOM
CDATASection interface, CDATASection
CharacterData interface, CharacterData
CORBA IDL, Understanding the DOM
Core, Feature Specifications
Document interface, Document
document objects, Getting a Document Object
documents
children, removing, Removing Nodes
editing, Changing Documents
nodes, Creating New Nodes
nodes, adding/removing, Adding and Moving Nodes
parents, replacing, Removing Nodes
structural changes, Changing a Document’s Structure
DocumentType interface, DocumentType
DOMException interface, DOMException
DOMImplementation interface, DOMImplementation
Element interface, Element
elements, extracting by name, Extracting Elements by Name
Entity interface, Entity
EntityReference interface, EntityReference
events, Feature Specifications
features, The DOM Specifications, Feature Specifications
hierarchy, Understanding the DOM–Understanding the DOM
history of, The DOM Specifications
information retrieval, Retrieving Information–Looking at Attributes
language-independence, Understanding the DOM
levels, The DOM Specifications, Levels of the Specification
minidom, Streamlining with Minidom
NamedNodeMap interface, NamedNodeMap
node lists, Getting a Node’s Children
node type, Determining a Node’s Type
NodeList interface, Getting a Node’s Children
nodes, The SAX and DOM APIs
children, Getting a Node’s Children
siblings, Getting a Node’s Siblings
Notation interface, Notation
overview, Basic DOM Operations
pulldom, Using Pulldom
Python and, Python DOM Offerings
range, Feature Specifications
SAX and, Python Tools for XML
specifications, The DOM Specifications
stylesheets, Feature Specifications
traversal, Feature Specifications
views, Feature Specifications
XML, Feature Specifications
DOMException interface, DOMException
DOMImplementation class, Building the XML document–Building the XML document
DOMImplementation interface, DOMImplementation
DOMStringSizeErr exception, DOMException
downloading Python, Installing Python
drivers, SAX, The Birth of SAX
DTDConsumer interface, xmlproc, Validation at Runtime
DTDHandler, SAX, DTDHandler
DTDs, Document Type Definitions, Document Type Definitions, Working with DTDs
Bill Summary, The BillSummary Example
entity declarations, Entity Declarations–Entity Declarations
external DTD subsets, Working with DTDs
validating, Validating with an External DTD Subset
internal DTD subsets, Working with DTDs
validating, Validating with the Internal DTD Subset
order.dtd file, Validating with an External DTD Subset
val.py, Validation at Runtime
Dynamic HTML (DHTML), The Document Object Model

E

ebXML, XML Validation and Dialects, What Does ebXML Offer?
document structure, ebXML Document Structure
phases, Phases of ebXML
ECMAScript, DOM and, Understanding the DOM
editing stylesheets, XSLT transformation, Creating a Stylesheet with Edit Functions
Electronic Business XML (see ebXML)
element content, content models, Content models
Element interface, Element
element types, declarations, Element Type Declarations–Content models
elementDecl( ) method, DeclHandler
elements
DOM, extracting by name, Extracting Elements by Name
indexed, Specifying an Index
namespaces, Namespaces in XML
XML, XML Structure in a Nutshell, Start, End, and Empty Element Tags, XML Definitions
content, XML Definitions
empty, XML Structure in a Nutshell, XML Definitions
XPath, selecting, Selecting Elements
embedded stylesheets, Embedded Stylesheets
embedding XSLT transformations, Embedding XSLT Transformations in Python–Selecting a Mode
empty elements, XML, XML Structure in a Nutshell, Start, End, and Empty Element Tags
encoding URLs, Encoding URLs
encodingStyle attribute, SOAP header, Using SOAP Headers
end tags, XML, Start, End, and Empty Element Tags, XML Definitions
end-of-line handling, End-of-Line Handling
endCDATA( ) method, LexicalHandler
endDocument( ) method, ContentHandler
endDTD( ) method, LexicalHandler
endElement( ) method, ContentHandler
endElementNS( ) method, ContentHandler
endEntity( ) method, LexicalHandler
endPrefixMapping( ) method, ContentHandler
entities, Physical Structures
declarations, DTDs, Entity Declarations–Entity Declarations
document entities, Physical Structures
external DTD subset, Physical Structures
external entities, Physical Structures
external, loading, EntityResolver
general entities, Entity Declarations
linked resources, Physical Structures
names, Physical Structures
parameter entities, Entity Declarations, Entity Declarations
parsed entities, Entity Declarations
system identifiers, Physical Structures
text entities, XML Definitions
uses, Physical Structures
XML, XML Definitions
external, XML Definitions
general, XML Definitions
internal entity replacement text, XML Definitions
literal values, XML Definitions
parameter, XML Definitions
Entity interface, Entity
entity references, Text, Character Data, and Markup
XML, XML Definitions
EntityHandler handler, SAX, EntityResolver
EntityReference interface, EntityReference
EntityResolver handler interface (SAX), EntityResolver
enumerated attribute values, XML, XML Definitions
enumerated attributes, Attribute data types, Attribute data types
Envelope element, SOAP, SOAP packet requirements
envelopes, SOAP, Constructing SOAP Envelopes
MSSOAP, Creating the SOAP envelope
packets, SOAP packet requirements
error messages, SOAP, Error Message and SOAP Fault
error( ) method, ErrorHandler
ErrorHandler interface
SAX, ErrorHandler, ErrorHandler
xmlproc, Validation at Runtime
ErrorPrinter class, ErrorHandler
errors
parsing errors, Handling Parsing Errors
XML, XML Definitions
escape, XML, XML Definitions
event handlers, SAX, index searches, Searching the Index
event-oriented interfaces, The SAX and DOM APIs
events
content-related, The SAX and DOM APIs
DOM, Feature Specifications
exceptions
DOMStringSizeErr, DOMException
HierarchyRequestErr, DOMException
IndexSizeErr, DOMException
InuseAttributeErr, DOMException
InvalidAccessErr, DOMException
InvalidCharacterErr, DOMException
InvalidModificationErr, DOMException
InvalidStateErr, DOMException
NamespaceErr, DOMException
NoDataAllowedErr, DOMException
NoModificationAllowedErr, DOMException
NotFoundErr, DOMException
NotSupportedErr, DOMException
SAX, SAX Exceptions
SyntaxErr, DOMException
WrongDocumentErr, DOMException
expressions, XPath
arithmetic operators, XPath Arithmetic Operators
compiling, Compiling XPath Expressions
Extensible Markup Language (see XML)
extensible stylesheet language transformations (see XSLT)
external DTD subset, Working with DTDs
entities, Physical Structures
validating, Validating with an External DTD Subset
external entities, Physical Structures
loading, EntityResolver
external entities, XML, XML Definitions
External markup declaration, XML, XML Definitions
externalEntityDecl( ) method, DeclHandler
extracting elements, DOM, Extracting Elements by Name

F

failure method, CGI, Defining success and error functions
fatal errors, XML, XML Definitions
fatalError( ) method, ErrorHandler
fault codes, SOAP, Fault codes
Fault element, SOAP, Error Message and SOAP Fault
features
DOM, The DOM Specifications, Feature Specifications
SAX, SAX Reader Objects
file template, pyxml.xml conversion, File Template
flat file
Bill Summary, The Flat File
validation, Conversion and Validation–Creating a validation handler
XML conversion, Conversion and Validation–Creating a validation handler
sample application, Understanding the Scope
XML conversion
CGI, Converting the flat file to XML
validation, Validating the converted XML
flat2xml.cgi file, Bill Summary and, The BillSummary Example
flatfile.cgi file, Starting the CGI
flatfile.html
Bill Summary and, The BillSummary Example
output, Running the Application in a Browser–Running the Application in a Browser
FlatfileParser
validation handlers, Creating a validation handler
XML conversion, Converting text to XML–Converting text to XML
XML validation, Validating the XML
FlatfileParser.py file
Bill Summary and, The BillSummary Example
flexibility, routing and, Routing Adds Flexibility
floor function, XPath, Working with Numbers
form tag, web form, The Web Form
forms, web forms, XML Validation and Dialects
FPIs (formal public identifiers), Physical Structures
frameworks, Dialects, Frameworks, and Workflow
fromXML( ) method, The Article class
FTP protocol, URLs, Opening URLs, Using FTP
functions
convenience, SAX, Convenience Functions
os.path.walk, Converting XML to HTML
PrettyPrint, Removing Nodes
xml.xpath.Evaluate, A Path Hosting Script
XPath, XPath Functions–Working with Nodes
floor, Working with Numbers
nodes and, Working with Nodes
string functions, Working with Strings
sum, Working with Numbers

G

Garshol, Lars Marius, The Birth of SAX
general entities, Entity Declarations
XML, XML Definitions
genhtml.py script, Driving the Conversion Handler–Driving the Conversion Handler
genxml.py script, Converting XML to HTML–Converting XML to HTML
generated documents, The Generated Document
GET
operations, Serving a GET
request, HTTP, Request Types
requests, Running a GET request
getAttribute( ) method, Looking at Attributes
getAttributeNode( ) method, Looking at Attributes
getByteStream( ) method, InputSource
getCharacterStream( ) method, InputSource
getColumnNumber( ) method, Locator
getContentHandler( ) method, XMLReader
getDTDHandler( ) method, XMLReader
getElementById( ) method, Document
getElementsByTagName( ) method, Extracting Elements by Name, Document
getElementsByTagNameNS( ) method, Document
getEncoding( ) method, InputSource
getEntityResolver( ) method, XMLReader
getErrorHandler( ) method, XMLReader
getException( ) method, SAX Exceptions
getFeature( ) method, XMLReader
getLineNumber( ) method, Locator
getMessage( ) method, SAX Exceptions
getProperty( ) method, XMLReader
getPublicId( ) method, InputSource, Locator
getSystemId( ) method, InputSource, Locator
getXML( ) method, The Article class, The Storage class
global namespaces, entities, Physical Structures
GUI (graphical user interface), Python and XML, Python and XML
Guido van Rossum, Python and XML

H

handler objects, SAX, SAX Handler Objects
handlers
collecting additional information, Using the Additional Information
PyXMLConversionHandler, The Conversion Handler–The Conversion Handler, Driving the Conversion Handler–Driving the Conversion Handler
SAX, The Birth of SAX
SAXThumbs, Implementing the SAXThumbs Handler–Implementing the SAXThumbs Handler
startElement, ContentHandler
writing, SAX, Writing a Simple Handler
XMLValidator and, Validation at Runtime
handlers.py script, The Conversion Handler–The Conversion Handler
hasFeature( ) method, DOMImplementation
HEAD method, Request Types
Header element, SOAP, SOAP packet requirements
headers, SOAP, Constructing SOAP Envelopes, Using SOAP Headers
hierarchy, Hierarchical Structure
HierarchyRequestErr exception, DOMException
history of Python, Python and XML
HTML, XML Fundamentals
converting from XML, Converting XML to HTML–Driving the Conversion Handler
pyxml.xml file, converting from, A More Complex Example–Method Template
replacing with XHTML, Replacing HTML with XHTML
HTTP
cookies, Baking Cookies for the Server
platform neutrality and, Platform Neutrality
POST operations, Performing a POST Operation–Illustrating a complete POST operation
Python and, Getting a Document with Python
request types, Request Types
response, SOAP, SOAP HTTP responses
SOAP and, SOAP over HTTP
SOAPAction header, The SOAPAction header
URLs, Opening URLs, Connecting with HTTP–Illustrating a complete POST operation
conversations, HTTP Conversations
httplib module, Connecting with HTTP
methods, Getting a Document with Python
POST operations, Performing a POST with httplib
Hypertext Transport Protocol (see HTTP)

I

id attribute, stylesheet elements, The Stylesheet Element
ID attributes, Attribute values and constraints
id function( ), XPath, Working with Nodes
IETF (Internet Engineering Task Force), The DOM Specifications
ignorableWhitespace( ) method, ContentHandler
IIS (Internet Information Server), Making the samples web-visible
implementation
interfaces, Validation at Runtime
POST operations, Serving a POST
implementation object, Document
Implementation phase, ebXML, Phases of ebXML
importNode( ) method, Document
includes, XML, XML Definitions
index.py script, Creating the IndexFile class–Running index.py
running from command line, Running index.py
indexDirectoryFiles( ) method, Creating the Index Generator
indexes
XPath, Specifying an Index
IndexSizeErr exception, DOMException
information extraction, XPath and, Extracting Information Using XPath
information modeling, ebXML and, Business Process and Modeling
InputSource class (SAX), InputSource
insertBefore( ) method, Adding and Moving Nodes
insertProfile( ) method, CustomerProfile class, Inserting and Deleting Profiles
installation
4Suite, Installing 4Suite
Python
Unix, Linux and Unix
Windows, Windows
PyXML, Installing PyXML
instantiation, server classes, Instantiating a server class
integers, XPath, XPath at a Glance
interfaces
Attr, DOM, Attr
CDATASection, DOM, CDATASection
CharacterData, DOM, CharacterData
ContentHandler, SAX, ContentHandler
CustomerProfile class, The Interfaces
DeclHandler, SAX, Other handler objects
Document, DOM, Document
DocumentType, DOM, DocumentType
DOMException, DOM, DOMException
DOMImpementation, DOM, DOMImplementation
Element, DOM, Element
Entity, DOM, Entity
EntityReference, DOM, EntityReference
EntityResolver, SAX, EntityResolver
ErrorHandler, SAX, ErrorHandler
event-oriented, The SAX and DOM APIs
implementation, Validation at Runtime
InputSource, SAX, EntityResolver
LexicalHandler, SAX, Other handler objects
Locator, SAX, ContentHandler, Locator
NamedNodeMap, DOM, NamedNodeMap
NodeList, NodeList
NodeList, DOM, Getting a Node’s Children
Notation, DOM, Notation
parsers, SAX, Native Parser Interfaces
reader, SAX, SAX Reader Objects
XMLOffer class, The interfaces
internal DTD subsets, Working with DTDs
validating, Validating with the Internal DTD Subset
internal entity replacement text, XML, XML Definitions
internalEntityDecl( ) method, DeclHandler
international language support, International Language Support
Internet support, Python Internet APIs
improvement, Continuing Improvement
web sites, Connecting Web Sites
interpreters, Python, The Power of Python and XML
portability, The Power of Python and XML
intro.html file, web application, The Components
InuseAttributeErr exception, DOMException
InvalidAccessErr exception, DOMException
InvalidCharacterErr exception, DOMException
InvalidModificationErr exception, DOMException
InvalidStateErr exception, DOMException
ISO (International Organization for Standardization), language support and, International Language Support
ISO-8859-1 character set, The ISO-8859-1 character set
iteration
NodeList object, Using a NodeList
stylesheet elements, Iterating over Elements

J

Java XML APIs, Python and XML

L

language identification, markup, Language Identification
language support, International Language Support
large XML files, A Large XML File
lastChild attribute, nodes and, Getting a Node’s Children
Latin-1 character set, The ISO-8859-1 character set
levels, DOM, The DOM Specifications, Levels of the Specification
LexicalHandler, SAX, Other handler objects, LexicalHandler
libraries, Python standard library, Python Tools for XML
line-feed characters, End-of-Line Handling
linked resources, entities, Physical Structures
Linux, Python installation, Linux and Unix
literal entity values, XML, XML Definitions
literal special characters, markup, Text, Character Data, and Markup
literals, Quotes around attribute values
loading documents
4DOM, Loading a document using 4DOM
minidom, Loading a document using minidom
MSXML, Basic DOM Operations
location paths, XPath, Location Paths
abbreviated location paths, Location Paths
Locator objects, SAX, Locator

M

mailing lists, Online Resources
makepy.py file, Fixing MSSOAP with makepy.py
make_parser function (SAX), Convenience Functions
markup, Application Neutrality
character data and, Text, Character Data, and Markup
characters used, Text, Character Data, and Markup
end-of-line handling, End-of-Line Handling
external declaration, XML Definitions
language identification, Language Identification
literal special characters, Text, Character Data, and Markup
XML, XML Definitions
markup languages versus meta-languages, XML 1.0 Recommendation
match attribute
template element, Creating a Template Element
xsl:template element, Standalone Stylesheets
Message Path, SOAP, Exchanging SOAP Messages
messages, SOAP
encoding, Encoding SOAP Messages
exchanging, Exchanging SOAP Messages
Message Path, Exchanging SOAP Messages
serialization, SOAP encoding style
meta-languages, XML 1.0 Recommendation
method
urlencode, Encoding URLs
method attribute, stylesheet elements, The Stylesheet Element
method definitions, genxml.py, Converting XML to HTML
method tag, web form, The Web Form
method template, pyxml.xml conversion, Method Template
methods
appendChild( ), Adding and Moving Nodes
appendStylesheetUri( ), Creating the CGI Script
attributeDecl( ), DeclHandler
characters( ), ContentHandler
comment( ), LexicalHandler
crateProcessingInstruction( ), Document
createAttribute( ), Document
createAttributeNS( ), Document
createCDATASection( ), Document
createComment( ), Document
createDocument( ), DOMImplementation, DOMImplementation
createDocumentFragment( ), Document
createDocumentType( ), Converting text to XML
createElement( ), Converting text to XML, Document
createElementNS( ), Document
createEntityReference( ), Document
createTextNode( ), Document
deleteProfile( ), Deleting a profile
Document object (MSXML), MSXML3.0 Document Object Methods
elementDecl( ), DeclHandler
endCDATA( ), LexicalHandler
endDocument( ), ContentHandler
endDTD( ), LexicalHandler
endElement( ), ContentHandler
endElementNS( ), ContentHandler
endEntity( ), LexicalHandler
endPrefixMapping( ), ContentHandler
error( ), ErrorHandler
externalEntityDecl( ), DeclHandler
fatalError( ), ErrorHandler
fromXML( ), The Article class
getAttribute( ), Looking at Attributes
getAttributeNode( ), Looking at Attributes
getByteStream( ), InputSource
getCharacterStream( ), InputSource
getColumnNumber( ), Locator
getContentHandler( ), XMLReader
getDTDHandler( ), XMLReader
getElementByID( ), Document
getElementsByTagName( ), Extracting Elements by Name, Document
getElementsByTagNameNS( ), Document
getEncoding( ), InputSource
getEntityResolver( ), XMLReader
getErrorHandler( ), XMLReader
getException( ), SAX Exceptions
getFeature( ), XMLReader
getLineNumber( ), Locator
getMessage( ), SAX Exceptions
getProperty( ), XMLReader
getPublicId( ), InputSource, Locator
getSystemID( ), InputSource, Locator
getXML( ), The Article class, The Storage class
hasFeature( ), DOMImplementation
HEAD( ), Request Types
ignorableWhitespace( ), ContentHandler
importNode( ), Document
indexDirectoryFiles( ), Creating the Index Generator
insertBefore( ), Adding and Moving Nodes
insertProfile( ), Inserting and Deleting Profiles
internalEntityDecl( ), DeclHandler
nextNode( ), Using a NodeList
Node class( ), Node Properties and Methods
Node object (MSXML), MSXML3.0 Node Object Methods
notationDecl( ), DTDHandler
parse( ), XMLReader
parseFile( ), Converting text to XML
POST( ), Request Types
postArticle( ), The ArticleManager class
processingInstruction( ), ContentHandler, ProcessingInstruction
PUT( ), Request Types
quote( ), Quoting URLs
removeChild( ), Adding and Moving Nodes
replaceChild( ), Adding and Moving Nodes
resolveEntity( ), EntityResolver, EntityResolver
setByteStream( ), InputSource
setCharacterStream( ), InputSource
setContentHandler( ), XMLReader
setDocumentLocator( ), ContentHandler, Locator
setDTDHandler( ), XMLReader
setEncoding( ), InputSource
setEntityResolver( ), EntityResolver, XMLReader
setErrorHandler( ), XMLReader
setFeature( ), XMLReader
setLocale( ), XMLReader
setProperty( ), XMLReader
setPublicId( ), InputSource
setSystemID( ), InputSource
skippedEntity( ), ContentHandler
startCDATA( ), LexicalHandler
startDocument( ), ContentHandler
startDTD( ), LexicalHandler
startElement( ), ContentHandler, Adding Intelligence, Implementing the SAXThumbs Handler, ContentHandler
startElementNS( ), ContentHandler
startEntity( ), LexicalHandler
startPrefixMapping( ), ContentHandler
Text( ), Text
unparsedEntityDecl( ), DTDHandler
viewAll( ), The ArticleManager class
viewOne( ), The ArticleManager class
warning( ), ErrorHandler
Microsoft COM, MSXML and, Setting Up MSXML3.0
Microsoft DOM, PyXML DOM and, Basic DOM Operations
minidom, DOM, Streamlining with Minidom
document loading, Loading a document using minidom
mixed content
content models, Content models
XML, XML Definitions
modeling, ebXML and, Business Process and Modeling
MSSOAP, Working with MSSOAP
COM support, Python, Getting Python COM support
makepy.py, Fixing MSSOAP with makepy.py
namespaces, Adding URIs and namespaces
requirements for, Requirements for Using MSSOAP
serialization, MSSOAP Serialization Basics
server, Server Setup
SOAP envelopes, Creating the SOAP envelope
SOAP Toolkit, Getting Microsoft SOAP Toolkit 2.0
URLs, Adding URIs and namespaces
MSXML
Document object, MSXML3.0 Document Object
methods, MSXML3.0 Document Object Methods
properties, MSXML3.0 Document Object Properties
load method, Basic DOM Operations
NamedNodeMap object, MSXML3.0 NamedNodeMap Object
Node lists, Using a NodeList
Node object, MSXML3.0 Node Object
methods, MSXML3.0 Node Object Methods
properties, MSXML3.0 Node Object Properties
NodeList object, MSXML3.0 NodeList Object
nodes, MSXML Nodes
objects, MSXML Nodes
ParseError object, MSXML3.0 ParseError Object
reference, MSXML3.0 Reference
setup, Setting Up MSXML3.0
SOAP Toolkit, Getting Microsoft SOAP Toolkit 2.0
transformations, Running an MSXML Transformation
XSLT and, MSXML3.0 Support for XSLT
mustUnderstand attribute, SOAP header, Using SOAP Headers

N

name tokens, Names
NamedNodeMap interface, NamedNodeMap
NamedNodeMap object, MSXML, MSXML3.0 NamedNodeMap Object
names
XML, XML Definitions
NamespaceErr exception, DOMException
namespaces, Names
attributes, Namespaces in XML
elements, Namespaces in XML
entities, Physical Structures
FPIs (formal public identifiers), Physical Structures
MSSOAP, Adding URIs and namespaces
SOAP, Encoding SOAP Messages
TCP/IP and, XML Namespaces
XML, Namespaces in XML, XML Namespaces
Namespaces recommendation (W3C), The Birth of SAX
neutrality
platforms, Platform Neutrality
nextNode( ) method, Using a NodeList
nextSibling attribute, Getting a Node’s Siblings
NoDataAllowedErr exception, DOMException
Node class, Node
constants, Node Constants
methods, Node Properties and Methods
properties, Node Properties and Methods
Node lists
DOM, Getting a Node’s Children
MSXML, Using a NodeList
Node object, MSXML, MSXML3.0 Node Object
methods, MSXML3.0 Node Object Methods
properties, MSXML3.0 Node Object Properties
NodeList interface, Getting a Node’s Children, NodeList
NodeList object, MSXML, MSXML3.0 NodeList Object
iterators, Using a NodeList
nodes
Comment, Comment
descendent nodes, XPath, Testing Descendent Nodes
DOM, Determining a Node’s Type
children, Getting a Node’s Children
siblings, Getting a Node’s Siblings
DOM API, The SAX and DOM APIs
firstChild attribute, Getting a Node’s Children
lastChild attribute, Getting a Node’s Children
MSXML, MSXML Nodes
nextSibling, Getting a Node’s Siblings
previousSibling, Getting a Node’s Siblings
values, Getting the Value of a Node
XPath functions, Working with Nodes
nodeType attribute, Determining a Node’s Type
NoModificationAllowedErr exception, DOMException
nonvalidating processors, Types of Conformance
Notation interface, Notation
notation, XML, XML Definitions
notationDecl( ) method, DTDHandler
NotFoundErr exception, DOMException
NotSupportedErr exception, DOMException
null values, SOAP encoding, SOAP Encoding Rules

O

OASIS consortium, ebXML and, What Does ebXML Offer?
object-orientation, The Power of Python and XML
object-oriented programming, Python and, Python and XML
objects
doctype, Document
Document, MSXML, MSXML3.0 Document Object
documentElement, Document
DocumentFragment, DocumentFragment
handler objects, SAX Handler Objects
implementation, Document
MSXML, MSXML Nodes
NamedNodeMap, MSXML, MSXML3.0 NamedNodeMap Object
Node object, MSXML, MSXML3.0 Node Object
NodeList, MSXML, MSXML3.0 NodeList Object
parseError, Handling Parsing Errors
ParseError, MSXML, MSXML3.0 ParseError Object
reader objects, SAX, SAX Reader Objects
SAXException, ErrorHandler
serialized, Hierarchical Structure
OfferXMLStore.xml file, A Large XML File
OMG (Object Managment Group), Understanding the DOM
online resources, Online Resources
opening URLs, Opening URLs
operators, XPath, Additional Operators
order.dtd file, Validating with an External DTD Subset
os.path.walk function, Converting XML to HTML

P

Page Templates, Page Templates
parameter entities, Entity Declarations, Entity Declarations
declarations, Entity Declarations
XML, XML Definitions
parent/child, XML, XML Definitions
parse( ) function, SAX, Convenience Functions
parse( ) method, XMLReader
parsed entities, Entity Declarations
parseError object, MSXML, Handling Parsing Errors, MSXML3.0 ParseError Object
parseFile( ) method, Converting text to XML
parser object, SAX, Using SAX in an Application
ParserFactory class, Advanced Parser Factory Usage
parsers, Hierarchical Structure
FlatfileParser, Converting text to XML–Converting text to XML
interfaces, SAX, Native Parser Interfaces
Microsoft, Setting Up MSXML3.0
SAX, SAX Reader Objects
validating parsers, XML Validation and Dialects
xmlproc package, Working with DTDs
parseString( ) function minidom, Loading a document using minidom
parseString( ) function, SAX, Convenience Functions
parseString() function minidom, The Article class
parsing
errors, Handling Parsing Errors
Pyxie, XML documents and, Pyxie, Pyxie
XML, Application Neutrality
PDAs, platform neutrality and, Platform Neutrality
performance, reduced, Python and XML
Perl, XML and, Python and XML
PIs (processing instructions), XML Definitions
XML, Processing Instructions
platform neutrality, Platform Neutrality
PNG (Portable Network Graphics), Entity Declarations
po.py script, Extracting Elements by Name
po.xml script, Extracting Elements by Name
popdb.py script, Populating the Database
populating database, sample application, Populating the Database
portability, Python interpreter, The Power of Python and XML
position function, XPath, Working with Nodes
POST
method, Request Types
operations
HTTP protocol, Performing a POST Operation–Illustrating a complete POST operation
implementing, Serving a POST
requests, Running a POST request–Running a POST request
post.py file, Illustrating a complete POST operation
postArticle( ) method, The ArticleManager class
postMsg.html file, Using postMsg.html to send back XML
PrettyPrint function, Removing Nodes
previousSibling attribute, Getting a Node’s Siblings
priority attribute, template element, Creating a Template Element
process declarations, XML, XML Definitions
processingInstruction( ) method, ContentHandler, ProcessingInstruction
processors
intermediate processors, SOAP, Exchanging SOAP Messages
nonvalidating, Types of Conformance
validating, Types of Conformance, XML Definitions
XML, XML Definitions
XSLT, XSLT Processors
Profiles database, sample application, Creating a Profiles Database
Access class, Building the Profiles Access Class
CompleteProfile class, The Complete CustomerProfile Class–The Complete CustomerProfile Class
connecting with, Connecting with the database
CustomerProfile class, Building the Profiles Access Class
retrieving profiles, Getting Profiles
updating profiles, Updating Profiles
XML document, Building the XML document–Building the XML document
ProgID, COM objects, Setting Up MSXML3.0
prolog, The Document Prolog
properties
Document object (MSXML), MSXML3.0 Document Object Properties
Node class, Node Properties and Methods
Node object (MSXML), MSXML3.0 Node Object Properties
SAX, SAX Reader Objects
Protocol Activity Web page, Communicating with XML Protocols
protocols
URLs, Opening URLs
XML Protocol Working group, Communicating with XML Protocols
pseudo-attributes, Processing Instructions
public identifiers, XML, XML Definitions
pulldom, DOM, Using Pulldom
PUT method, Request Types
PyExpat, Using PyExpat Directly, Using PyExpat Directly
Python
code
maintenance, The Power of Python and XML
readability, The Power of Python and XML
command-line, running from, Windows
DOM and, Python DOM Offerings
downloading, Installing Python
history, Python and XML
installation
Unix, Linux and Unix
Windows, Windows
interpreters, The Power of Python and XML
library, minidom, Streamlining with Minidom
SOAP client, A Python SOAP Client
SOAP options, Python SOAP Options
tools for XML, Python Tools for XML
Python standard library, Python Tools for XML
PyXML, Python Tools for XML
XML and, The Power of Python and XML–More Ways to Extract Information
applications, What Can We Do with It?
XML extraction, Converting XML to HTML
XML Schema validator, XML Schema Validator
XML Tools, Python XML Tools
Python Distribution Utilities, Installing PyXML
Python Library Reference, Understanding the DOM, Python SAX API
Python standard library, Python Tools for XML
PYX, Pyxie
Pyxie, Pyxie–Pyxie
PyXML, Python Tools for XML
installation, Installing PyXML
minidom, Streamlining with Minidom
XML conversion to HTML and, Converting XML to HTML–Driving the Conversion Handler
PyXML DOM, Microsoft DOM and, Basic DOM Operations
pyxml.xml file, The Generated Document
class template, conversion and, Class Template
converting to HTML, A More Complex Example–Method Template
file template, conversion and, File Template
method template, conversion and, Method Template
PyXMLConversionHandler class, The Conversion Handler–The Conversion Handler, Driving the Conversion Handler–Driving the Conversion Handler

Q

query strings
URLs, Working with URLs
quote( ) method, urllib module, Quoting URLs
quotes, attribute values, Quotes around attribute values

R

range, DOM, Feature Specifications
RDF (Resource Description Framework) data, Redfoot and, Redfoot
reader objects, SAX, SAX Reader Objects
readers, SAX, Using SAX in an Application
Redfoot, Redfoot
reduced performances, Python and XML
references
character references, Text, Character Data, and Markup
entity references, Text, Character Data, and Markup
relational database, sample application, Understanding the Scope
building, Building the Database–Populating the Database
RELAX-NG schema language, RELAX-NG
removeChild( ) method, Adding and Moving Nodes
replaceChild( ) method, Adding and Moving Nodes
replacement text, XML Definitions
internal entities, XML Definitions
requests, HTTP protocol, Request Types
resolveEntity( ) method, EntityResolver, EntityResolver
retrieving URLs, Retrieving URLs
revision tracking, Word, Application Neutrality
root element, XML Definitions
routing
flexibility and, Routing Adds Flexibility
scalability and, Routing Adds Scalability
SOAP messages and, Exchanging SOAP Messages
RPCs (Remote Procedure Calls), SOAP and, SOAP Encoding Techniques, SOAP for RPC
RTF (Rich Text Format), Application Neutrality
Run Time phase, ebXML, Phases of ebXML
runtime, validation at, Validation at Runtime
runxs.py file, Running the XML Switch

S

Sab-pyth, Sab-pyth
Sablotron XSLT processor, XSLT Processors, Sab-pyth
sample application
Customer table, Creating a Customer Table
decoupling application systems, Decoupling Application Systems
Profiles database, Creating a Profiles Database
connecting with, Connecting with the database
CustomerProfile class, Getting Profiles
CustomerProfile classq, The Interfaces
CustomerProfile Python class, Building the Profiles Access Class
populating, Populating the Database
updating profiles, Updating Profiles
XML document, Building the XML document–Building the XML document
routing and, Routing Adds Flexibility
scalabity and, Routing Adds Scalability
scope, Understanding the Scope
XML access object, Creating an XML Access Object
XML Data Store, Creating an XML Data Store–Modification methods
XML Switch, The XML Switch–Running the XML Switch
architecture, XML Architecture
classes, Core XML Switch Classes
running, Running the XML Switch–Running the XML Switch
XML Switch client, The XML Switch Client
XML Switch service, The XML Switch Service
XMLMessage class, The XMLMessage Class–XMLMessage code listing
XMLOffer class, Using the XMLOffer class
creating, Creating the XMLOffer class–Modification methods
XMLSwitchHandler Server class, The XMLSwitchHandler Server Class–XMLSwitchHandler code architecture
xsc, Using the XSC client
XSC API, Using the XSC API–The XMLSwitchHandler Server Class
see also web application, A Web Application
SAX, The SAX and DOM APIs–The SAX and DOM APIs, The Simple API for XML, Python SAX API, ErrorHandler
applications, Using SAX in an Application
article reading, Reading an Article–Using the Additional Information
ContentHandler interface, ContentHandler, ContentHandler
DeclHandler interface, DTDHandler, Other handler objects, DeclHandler
drivers, The Birth of SAX
DTDHandler, DTDHandler
EntityResolver interface, EntityResolver, EntityResolver, EntityResolver
ErrorHandler interface, ErrorHandler
event handlers, index searches, Searching the Index
exceptions, SAX Exceptions
features, SAX Reader Objects
functions, convenience functions, Convenience Functions
handler objects, SAX Handler Objects
handlers, The Birth of SAX
writing, Writing a Simple Handler
history of, The Birth of SAX
image indexes, Building an Image Index–Viewing Your Thumbnails
index generator, Creating the Index Generator–Running index.py
indexes, Searching File Information
InputSource interface, EntityResolver, InputSource
intelligence, Adding Intelligence
LexicalHandler interface, Other handler objects, Other handler objects, LexicalHandler
Locator interface, ContentHandler
Locator objects, Locator
overview, Understanding SAX–SAX Reader Objects
parser object, Using SAX in an Application
ParserFactory class, Advanced Parser Factory Usage
parsers, SAX Reader Objects
parsers interface, Native Parser Interfaces
properties, SAX Reader Objects
pulldom and, Using Pulldom
reader interface, SAX Reader Objects
reader objects, SAX Reader Objects
readers, Using SAX in an Application
saxthumbs.py, Implementing the SAXThumbs Handler
searches, file information, Searching File Information–Searching the Index
thumbmaker.py, Implementing the SAXThumbs Handler
XMLReader interface, Reading an Article, XMLReader
SAX2, The Birth of SAX
SAXException exception class, ErrorHandler, SAX Exceptions
saxfinder.py script, Searching the Index–Searching the Index
SAXNotRecognizedException subclass, SAX Exceptions
SAXNotSupportedException subclass, SAX Exceptions
SAXON, XSLT Processors
SAXParseException exception class, Locator
SAXParseException subclass, SAX Exceptions
SAXThumbs handler, Implementing the SAXThumbs Handler–Implementing the SAXThumbs Handler
saxthumbs.py script, Building an Image Index, Implementing the SAXThumbs Handler
scalability, routing and, Routing Adds Scalability
schema languages, Document Types and Schemas
RELAX-NG, RELAX-NG
Schematron Assertion Language, Schematron
TREX, TREX
XML alternate languages, Alternate Schema Languages–Schematron
XML Schema, XML Schema
schema valid documents, Types of Conformance
schemas, XML, Document Types and Schemas
Schematron Assertion Language, Schematron
scope, sample application, Understanding the Scope
searches
character data, XPath, Getting Character Data
file information, Searching File Information–Searching the Index
indexes, SAX event handlers, Searching the Index
URLs, Working with URLs
select attribute
xsl:for-each element, Iterating over Elements
xsl:value-of element, Getting the Value of a Node
serialization, MSSOAP, MSSOAP Serialization Basics
serialized objects, Hierarchical Structure
server classes, Using the Server Classes
Base, Server Core Concepts
BaseHTTPRequestHandler, Using the Server Classes
BaseHTTPServer module, Using the Server Classes, BaseHTTPServer Module Classes
core concepts, Server Core Concepts
GET operations, Serving a GET
GET requests, Running a GET request
instantiating, Instantiating a server class
POST requests, Running a POST request–Running a POST request
XMLSwitchHandler, The XMLSwitchHandler Server Class–XMLSwitchHandler code architecture
servers
building, Building a Complete Server
MSSOAP, Server Setup
SOAP, Server Setup
web, Preparing the Web Server
setByteStream( ) method, InputSource
setCharacterStream( ) method, InputSource
setContentHandler( ) method, XMLReader
setDocumentLocator( ) method, ContentHandler, Locator
setDTDHandler( ) method, XMLReader
setEncoding( ) method, InputSource
setEntityResolver( ) method, EntityResolver, XMLReader
setFeature( ) method, XMLReader
setLocale( ) method, XMLReader
setProperty( ) method, XMLReader
setPublicId( ) method, InputSource
setSystemID( ) method, InputSource
setup, MSXML, Setting Up MSXML3.0
SGML (Standard Generalized Markup Language), XML Fundamentals
sh-bang, Preparing the Web Server
shell scripting, XML and, Python and XML
SIGs (Special Interest Groups), Online Resources
Simple API for XML (see SAX)
simplfied stylesheets, Simplified Stylesheets–Simplified Stylesheets
site logic, web applications, Implementing Site Logic–Controlling the Application
skippedEntity( ) method, ContentHandler
SOAP, Python Web Services Support
arrays, Compound Types
as client[SOAP
client), Example SOAP Server and Client
Body element, SOAP packet requirements, SOAP Body Elements
data types, Simple Types
encoding
rules for, SOAP Encoding Rules
techniques, SOAP Encoding Techniques
Envelope element, SOAP packet requirements
envelopes, Constructing SOAP Envelopes
MSSOAP, Creating the SOAP envelope
packets, SOAP packet requirements
error messages, Error Message and SOAP Fault
fault codes, Fault codes
Fault element, Error Message and SOAP Fault
Header element, SOAP packet requirements
headers, Constructing SOAP Envelopes, Using SOAP Headers
HTTP and, SOAP over HTTP
HTTP responses, SOAP HTTP responses
intermediate processors, Exchanging SOAP Messages
messages
encoding, Encoding SOAP Messages
exchanging, Exchanging SOAP Messages
Message Path, Exchanging SOAP Messages
serialization, SOAP encoding style
MSSOAP, Working with MSSOAP
namespaces, Encoding SOAP Messages
Python client, A Python SOAP Client
Python options, Python SOAP Options
RPC-style development, SOAP for RPC
RPCs, SOAP Encoding Techniques
as server, Example SOAP Server and Client
servers, Server Setup
structs, Compound Types
XML-RPC and, What About XML-RPC?
SOAP toolkit, Getting Microsoft SOAP Toolkit 2.0
SOAPAction header, HTTP, The SOAPAction header
SoapAction value, Exchanging SOAP Messages
SOAPy, Working with SOAPy
source XML, XSLT transformation embedding, Creating the Source XML
sp.py file, The Components–Running the Site as a User
web application, The Components
special characters, CDATA sections, CDATA Sections
SQL Enterprise Manager, sample application, Creating a Profiles Database
Customer table, Creating a Customer Table
stand-alone stylesheets, Standalone Stylesheets–Standalone Stylesheets
standard library, Python Tools for XML
start page, web application, The Code Architecture
start tag, XML, Start, End, and Empty Element Tags, XML Definitions
start.cgi script, The Web Application Structure
startCDATA( ) method, LexicalHandler
startDocument( ) method, ContentHandler
startDTD( ) method, LexicalHandler
startElement( ) method, ContentHandler, Adding Intelligence, Implementing the SAXThumbs Handler, ContentHandler
startElementNS( ) method, ContentHandler
startEntity( ) method, LexicalHandler
startPrefixMapping( ) method, ContentHandler
starts-with function, XPath, Working with Strings
Storage class, web application, The Storage class
Storage.py script, The Storage class
stream-based APIs, Understanding SAX
string functions, XPath, Working with Strings
string-length function, XPath, Working with Strings
StringIO class, Converting text to XML
strings, Attribute data types
#FIXED constraint, Attribute values and constraints
#REQUIRED constraint, Attribute values and constraints
SOAP encoding, SOAP Encoding Rules
structs, SOAP, Compound Types
stylesheets
DOM, Feature Specifications
embedded, Embedded Stylesheets
embedding in XML documents, Setting Up MSXML3.0
iterating over elements, Iterating over Elements
stand-alone, Standalone Stylesheets–Standalone Stylesheets
templates, applying, Applying Templates
XSL, XSL Stylesheet
XSLT, The XSLT Specification
transformation embedding, Creating a Simple Stylesheet
xsl:apply-templates, Applying Templates
xsl:for-each, Iterating over Elements
xsl:stylesheet, Standalone Stylesheets, The Stylesheet Element
xsl:template, Creating a Template Element
xsl:transform, Standalone Stylesheets, The Stylesheet Element
xsl:value-of element, Getting the Value of a Node
substring function, XPath, Working with Strings
success method, CGI, Defining success and error functions
sum function, XPath, Working with Numbers
symbols used in markup, Text, Character Data, and Markup
SyntaxErr exception, DOMException
system identifiers, Physical Structures
XML, XML Definitions
SystemLiteral, XML Definitions

T

tags, XML, XML Structure in a Nutshell
end tags, Start, End, and Empty Element Tags, XML Definitions
start tags, Start, End, and Empty Element Tags, XML Definitions
termdef, XML Definitions
targets, XML, Processing Instructions
TCP/IP, Python, Web Services, and SOAP
templates, applying, Applying Templates
termdef tags, XML Definitions
testing attributes, XPath, Testing Attributes
text, Text, Character Data, and Markup
Python and, Python and XML
replacement text, XML Definitions
RTF (Rich Text Format), Application Neutrality
XML, XML Definitions
text entities, XML, XML Definitions
text function, XPath, Getting Character Data
Text( ) method, Text
textarea tag, web form, The Web Form
textme.py script, Examining NodeList Members
thumbmaker.py, Implementing the SAXThumbs Handler
thumbnails
creating, Creating Thumbnail Images–Creating thumbnails on Windows
saxthumbs.py, Building an Image Index, Implementing the SAXThumbs Handler
thumbmaker.py, Implementing the SAXThumbs Handler
viewing, Viewing Your Thumbnails
Windows, Creating thumbnails on Windows
tokenized attributes, Attribute data types, Attribute data types
tokens, name tokens, Names
tools for XML, Python Tools for XML
4Suite, Python Tools for XML
Python standard library, Python Tools for XML
PyXML, Python Tools for XML
topology, web application, The Topology
transformations
MSXML, Running an MSXML Transformation
XSLT and, The XSLT Specification
embedding, Embedding XSLT Transformations in Python–Selecting a Mode
translate function, XPath, Working with Strings
Transmission Control Protocol/Internet Protocol (see TCP/IP)
traversal, DOM, Feature Specifications
TREX (Tree Regular Expressions for XML) schema language, TREX

U

UDDI (Universal Discovery, Description, and Integration), Python, Web Services, and SOAP
UML (Universal Modeling Language), Business Process and Modeling
UMM (UN/CEFACT Modeling Methodology), Business Process and Modeling
UN/CEFACT body, ebXML and, What Does ebXML Offer?
Unicode, Characters in XML Documents
Unicode Consortium, language support and, International Language Support
Universal Resource Locators (see URLs)
Unix
Python installation, Linux and Unix
PyXML installation, Installing PyXML
unparsed entities, XML, XML Definitions
unparsedEntityDecl( ) method, DTDHandler
unquoting URLs, Unquoting URLs
urllib module, Python to the Rescue
quote method, Quoting URLs
urlencode method, Encoding URLs
urlopen function, Opening URLs
urlretrieve function, Retrieving URLs
see also httplib module, Connecting with HTTP
urlopen function, Opening URLs
URLs, Python to the Rescue
basic format, Working with URLs
encoding, Encoding URLs
encoding, POST operations, Ensuring proper URL encoding
FTP protocol, Using FTP
HTTP protocol, Connecting with HTTP–Illustrating a complete POST operation
conversations, HTTP Conversations
MSSOAP, Adding URIs and namespaces
opening, Opening URLs
protocols, Opening URLs
quoting, Quoting URLs
retrieving, Retrieving URLs
unquoting, Unquoting URLs
User-Agent, HTTP Conversations
UTF-8 encoding (Universal Transformation Format, 8-bit), UTF-8 Encoding
utilities
distutils, Installing PyXML
Python Distribution Utilities, Installing PyXML

V

val.py, DTDs and, Validation at Runtime
validating
external DTD subset, Validating with an External DTD Subset
internal DTD subset, Validating with the Internal DTD Subset
validating parsers, XML Validation and Dialects
xmlproc package, Working with DTDs
validating processors, Types of Conformance
validation, Types of Conformance
converted XML, Validating the converted XML
flat file, Bill Summary, Conversion and Validation–Creating a validation handler
processor, XML Definitions
XML documents, runtime, Validation at Runtime
XML Schema validator, XML Schema Validator
validation handlers, xmlproc, Creating a validation handler
validity constraints, XML Definitions
validity, XML, XML Definitions
ValidityError.py file, Bill Summary and, The BillSummary Example
ValidityErrorHandler, Displaying the XML
values
attributes, Attribute values and constraints
nodes, Getting the Value of a Node
van Rossum, Guido, Python and XML
version attribute, stylesheet elements, The Stylesheet Element
viewAll( ) method, The ArticleManager class
viewOne( ) method, The ArticleManager class
views, DOM, Feature Specifications

W

warning( ) method, ErrorHandler
web application sample, A Web Application
CGI, The CGI Functionality
code architecture, The Code Architecture
components, The Components
connecting to web service, Connecting to a Web Service
profile updating, Updating profile information
start page, The Code Architecture
testing as user, Running the Site as a User
topology, The Topology
see also sample application, A Web Application
web applications
Article class, The Article class–The Storage class
ArticleManager class, The ArticleManager class–Controlling the Application
control, Controlling the Application–Controlling the Application
script execution, Ensuring the script’s execution
server preparation, Preparing the Web Server
site logic, Implementing Site Logic–Controlling the Application
Storage class, The Storage class
structure, The Web Application Structure–Implementing Site Logic
write permissions, Enabling write permission
web forms, XML Validation and Dialects
Bill Summary and, The Web Form
web services, Python, Web Services, and SOAP
connecting to, Connecting to a Web Service
content syndication, Python, Web Services, and SOAP
support, Python Web Services Support
web sites, Online Resources
connecting, Connecting Web Sites
XML specifications, XML as a Foundation
Web/CGI application
components, The Components
sample application, Understanding the Scope
well-formed, Types of Conformance
well-formed documents, XML, XML Definitions
well-formedness constraint, XML documents, XML Definitions
whitespace, character data, Whitespace in Character Data–Whitespace in Character Data
Windows
Python installation, Windows
PyXML installation, Installing PyXML
thumbnails, Creating thumbnails on Windows
Word, revision tracking, Application Neutrality
workflow, Dialects, Frameworks, and Workflow
primary objective, Dialects, Frameworks, and Workflow
write permissions, web applications, Enabling write permission
writing handlers, SAX, Writing a Simple Handler
WrongDocumentErr exception, DOMException
WSDL (Web Services Description Language), Python, Web Services, and SOAP

X

XHTML (Extensible Hypertext Markup Language), Replacing HTML with XHTML
XLink, Using XLink to Link XML Documents
XML
advantages of, Key Advantages of XML
international language support, International Language Support
platform neutrality, Platform Neutrality
attribute-list declarations, XML Definitions
attributes, XML Structure in a Nutshell, XML Definitions
defaults, XML Definitions
names, XML Definitions
values, XML Definitions
values, enumerated, XML Definitions
Canonical XML, Canonical XML–Canonical XML Structure
CDATA sections, XML Definitions
characters, Characters in XML Documents–UTF-8 Encoding, XML Definitions
child, XML Definitions
comments, Comments
conformance, Types of Conformance
conversion
flat file, Converting the flat file to XML
validation, Validating the converted XML
converting
to HTML, Converting XML to HTML–Driving the Conversion Handler
to PYX, Pyxie
declarations, XML Structure in a Nutshell
definitions, XML Definitions–XML Definitions
displaying, CGI, Displaying the XML
document structure, XML Structure in a Nutshell
document types, Document Types and Schemas
documents
characters in, Characters in XML Documents–UTF-8 Encoding
data types and, Document Types and Schemas
parsing, Pyxie, Pyxie, Pyxie
prolog, The Document Prolog
well-formed, XML Definitions
well-formed constraint, XML Definitions
XLink, Using XLink to Link XML Documents
XPath expressions and, XPath at a Glance
DOM, Feature Specifications
DTDs, Document Type Definitions
elements, XML Structure in a Nutshell, Start, End, and Empty Element Tags
empty, XML Structure in a Nutshell
empty elements, Start, End, and Empty Element Tags
files, XSLT and, The XSLT Specification
as foundation, XML as a Foundation
intelligence, Adding Intelligence
Java XML APIs, Python and XML
large XML files, A Large XML File
namespaces, Namespaces in XML, XML Namespaces
parsing, Application Neutrality
physical structures, Physical Structures
processing instructions, Processing Instructions
Python and, The Power of Python and XML–More Ways to Extract Information
applications, What Can We Do with It?
Python combination, Python and XML
schema languages, alternate, Alternate Schema Languages–Schematron
schemas, Document Types and Schemas
SOAP message encoding, Encoding SOAP Messages
source code
XSLT transformation embedding, Creating the Source XML
specifications, The XML Specifications–More Ways to Extract Information
start tags, Start, End, and Empty Element Tags
tags, XML Structure in a Nutshell
targets, Processing Instructions
tools for, Python, Python Tools for XML, Python XML Tools
4Suite, Python Tools for XML
Python standard library, Python Tools for XML
PyXML, Python Tools for XML
unparsed entities, XML Definitions
validity, XML Definitions
validity constraints, XML Definitions
XSLT and, Transforming XML with XSLT
XML 1.0, XML 1.0 Recommendation
XML access object, sample application, Creating an XML Access Object
XML Data Store, sample application, Creating an XML Data Store–Modification methods
XML declaration, The Document Prolog, XML Definitions
XML documents, XML Definitions
sample application, Building the XML document–Building the XML document
validation, runtime, Validation at Runtime
XML processor, XML Definitions
XML Protocol Working group, Communicating with XML Protocols
XML Schema, XML Schema
XML Schema validator, XML Schema Validator
XML Stylesheet Language Transformations (see XSLT)
XML Switch, sample application, Understanding the Scope, The XML Switch–Running the XML Switch
architecture, XML Architecture
classes, Core XML Switch Classes
running, Running the XML Switch–Running the XML Switch
XML Switch client, The XML Switch Client
XML Switch service, The XML Switch Service
XMLMessage class, The XMLMessage Class–XMLMessage code listing
XML-generating indexing routines, Searching File Information
XML-RPC, What About XML-RPC?
xml.parsers package, xmlproc package, Working with DTDs
xml.xpath.Evaluate function, A Path Hosting Script
XMLMessage class, Core XML Switch Classes
XMLOffer class, sample application, Creating an XML Access Object
creating, Creating the XMLOffer class–Modification methods
interfaces, The interfaces
xmlproc, Working with DTDs
DTDConsumer interface and, Validation at Runtime
ErrorHandler interface and, Validation at Runtime
validation handlers, Creating a validation handler
XMLReader interface, XMLReader
xmlrpclib module, What About XML-RPC?
XMLSwitchHandler, Core XML Switch Classes, Core XML Switch Classes, The XML Switch Service
XMLSwitchHandler Server class, sample application, The XMLSwitchHandler Server Class–XMLSwitchHandler code architecture
XMLValidator, Validation at Runtime, Creating a validation handler
xml:lang attribute, Language Identification
xml:space attribute, Whitespace in Character Data
XPath, More Ways to Extract Information, Extracting Information Using XPath, Querying XML with XPath
abbreviated location paths, Location Paths
attributes, testing, Testing Attributes
character data searches, Getting Character Data
context, XPath at a Glance
descendent nodes, Testing Descendent Nodes
elements, selecting, Selecting Elements
example document, An Example Document
expressions
arithmetic operators and, XPath Arithmetic Operators
compiling, Compiling XPath Expressions
XSLT, Where Is XPath Used?
functions, XPath Functions–Working with Nodes
floor, Working with Numbers
nodes and, Working with Nodes
string functions, Working with Strings
sum, Working with Numbers
indexes, Specifying an Index
integers, XPath at a Glance
location paths, Location Paths
nodes, functions and, Working with Nodes
operators, Additional Operators, XPath Arithmetic Operators
overview, XPath at a Glance
path hosting script, A Path Hosting Script
text function, Getting Character Data
where used, Where Is XPath Used?
XSC API, Using the XSC API–The XMLSwitchHandler Server Class
xsc class, Core XML Switch Classes
xsc client, sample application, Using the XSC client
XSL
command line use, Using XSLT from the Command Line
stylesheets, XSL Stylesheet
XSLT, More Ways to Extract Information
4XSLT and, XSLT Processors
bridges, XSLT Processors
CSS, defining, Defining Stylesheets
MSXML and, MSXML3.0 Support for XSLT
Sablotron, XSLT Processors
SAXON and, XSLT Processors
specification, The XSLT Specification
stylesheets, The XSLT Specification
transformation results, The XSLT Specification
transformations, embedding, Embedding XSLT Transformations in Python–Selecting a Mode
XML and, Transforming XML with XSLT
XML file, The XSLT Specification
XPath expressions, Where Is XPath Used?
XSLT processors, XSLT Processors
xsl:apply-templates element, Applying Templates
nesting and, Creating a Template Element
xsl:element, Simplified Stylesheets
xsl:for-each element, Iterating over Elements
xsl:output element, The Stylesheet Element
xsl:stylesheet element, Standalone Stylesheets, The Stylesheet Element
embedded elements and, Embedded Stylesheets
xsl:template element, Creating a Template Element
match attribute, Standalone Stylesheets
xsl:transform element, Standalone Stylesheets, The Stylesheet Element
embedded elements and, Embedded Stylesheets
xsl:value-of element, Getting the Value of a Node
xvcmd.py command-line routine, Validating with the Internal DTD Subset
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.148.117.212