convert pdf to tiff c# : Add signature to pdf acrobat reader software Library dll windows .net azure web forms Python%20and%20XML2-part1649

IT-SC book 
19
type would have to specify the particular prefixes to which each namespace is bound, while the 
Namespaces  specification  allows  prefixes  to  be  determined  by  the  document  rather  than  the 
schema. Alternate schema languages that have better support for Namespaces have been defined; 
these are discussed briefly in 
Chapter 2
.  
1.2.3 XML as a Foundation 
Like its predecessor SGML, XML provides a way to define languages that fit the requirements of 
your  application.  By  specifying  the  exact  syntax  of  the  grammatical  elements  (such  as  the 
characters  used  to  mark  the  start  of  an  element),  it has  reduced  the  effort  required  to  build 
conforming software—the components needed to extract an application's data from XML are far 
smaller and simpler to use than the corresponding components are for SGML.  
The additional specifications, which the trade press so enjoy discussing every time a news release 
comes out, are generally built by defining new languages using the base XML and Namespaces 
recommendations. These are often documented by schema definitions (the forms that these take 
are described in 
Chapter 2
) as well as committee-driven documents that attempt to explain how 
the language should be used. Since every industry has at least one consortium that deals in part 
with data interchange between different components of the industry (think of doctors, pharmacies, 
and hospitals in the health care field), many standards take this form. Many of the standards for 
XML are derived from earlier efforts using older SGML industry-specific languages, and many 
are new.  
Locating information about the languages that have been defined for your industry may be easy 
or it may be difficult. There are many resources you can use to locate relevant specifications:  
http://www.schema.net/
This web site contains information on a range of standards based  on XML, 
including general business-oriented specifications, industry-specific standards, 
interoperable languages for academic research, and general Internet-related 
specifications.  
http://www.biztalk.com/
Information  about  the  Microsoft-sponsored  "BizTalk"  range  of  business 
interoperability specifications can be found at this web site.  
http://www.ebxml.org/
The "e-business XML" initiative, or ebXML, grows out of the EDI community, 
and generally competes with BizTalk.  
http://www.w3.org/
For general Internet-related specifications, the World Wide Web Consortium is 
perhaps  the  best  place  to  look;  the  working  groups  there  have  a  broad 
constituency  and  the  results  of  their  efforts  have  a  high  level  of  uptake 
wherever they apply.  
http://www.google.com/
Add signature to pdf acrobat reader - C# PDF File Permission Library: add, remove, update PDF file permission in C#.net, ASP.NET, MVC, WPF
Tell C# users how to set PDF file permissions, like printing, copying, modifying, extracting, annotating, form filling, etc
export pdf sign in; add signature to pdf file
Add signature to pdf acrobat reader - VB.NET PDF File Permission Library: add, remove, update PDF file permission in vb.net, ASP.NET, MVC, WPF
VB.NET Tutorial for How to Set PDF File Access Permissions Using XDoc.PDF for .NET
create pdf signature field; pdf converter sign in
IT-SC book 
20 
If all else fails, try searching here for "XML" and various keywords related to 
your industry (especially the names of major industry consortia).  
1.3 The Power of Python and XML 
Now that we've introduced you to the world of XML, we'll look at what Python brings to the table. 
We'll review the Python features that apply to XML, and then we'll give some specific examples 
of  Python  with  XML.  As  a  very  high-level  language,  Python  includes  many  powerful  data 
structures as part of the core language and libraries. The more recent versions of Python, from 2.0 
onward, include excellent support for Unicode and an impressive range of encodings, as well as 
an excellent (and fast!) XML parser that provides character data from XML as Unicode strings. 
Python's standard library also contains implementations of the industry-standard DOM and SAX 
interfaces for working with XML data, and additional support for alternate parsers and interfaces 
is available.  
Of course, this much could be said of other modern high-level languages as well. Java certainly 
includes an impressive library of highly usable data structures, and Perl offers equivalent data 
structures also. What makes Python preferable to those languages and their libraries? There are 
several features, of which we briefly discuss the most important:  
Python source code is easy to read and maintain. 
The interactive interpreter makes it simple to try out code fragments. 
Python is incredibly portable, but does not restrict access to platform-specific capabilities.  
The object-oriented features are powerful without being obscure. 
There are many languages capable of doing what can be done with Python, but it is rare to find all 
of the "peripheral" qualities of Python in any single language. These qualities do not so much 
make Python more capable, but they make it much easier to apply, reducing programming hours. 
This allows more time to be spent finding better ways to solve real problems or just allows the 
programmer to move on to the next problem. Here we discuss these features in more detail.  
Easy to read and maintain  
As  a  programming  language,  Python  exhibits  a  remarkable  clarity  of 
expression. Though some programmers accustomed to other languages view 
Python's use of significant whitespace with surprise, everyone seems to think 
it makes Python source code significantly more readable than languages that 
require  more  special  characters  to  be  introduced  to  mark  structure  in  the 
source. Python's structures are not simpler than those of other languages, but 
the different syntax makes source code "feel" much cleaner in Python.  
The use of whitespace also helps avoid having minor stylistic differences, such 
as the placement of structural braces, so there's a greater degree of visual 
consistency across code by different programmers. While this may seem like 
 minor  thing  to  many  programmers,  the  effect  is  that  maintaining  code 
written  by  another  programmer  becomes  much  easier  simply  because  its 
easier to concentrate on the actual structure and algorithms of the code. For 
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
Also designed to be used add-on for .NET Image SDK, RasterEdge Powerful image converter for Bitmap and PDF files; No need for Adobe Acrobat Reader & print
add jpeg signature to pdf; pdf signature
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
It can be used standalone. JPEG to PDF Converter is able to convert image files to PDF directly without the software Adobe Acrobat Reader for conversion.
create pdf signature; adding signature to pdf
IT-SC book 
21
the individual programmer, this is a nice side benefit, but for a business, this 
results in lower expenses for code maintenance.  
Exploratory programming in an interactive interpreter  
Many modern high-level programming languages offer interpreters, but few 
have proved as successful at doing so as Python. Others, such as Java, do not 
generally  offer  interpreters  at  all.  If  we  consider  Perl,  a  language  that  is 
arguably very capable when used from a command line, we see that it is not 
equipped  with  a  rich  interpreter.  If  we  start  the  Perl  interpreter  without 
naming a script, it simply waits for us to type a complete script at the console, 
and then interprets the script when we're done. It does allow us to enter a 
few commands on the command line directly, but there's no ability to run one 
statement at a time and inspect the results as we go in order to determine if 
each bit of code is doing exactly what we expect. With Python, the interactive 
interpreter provides  a rich environment  for executing  individual statements 
and testing the results.  
Portability without restrictions  
The  Python  interpreter  is  one  of  the  most  portable  language  interpreters 
available.  It  is  known  to  run  on  platforms  ranging  from  PDAs  and  other 
embedded systems  to some  of  the  most powerful multiprocessor platforms 
ever  built.  It  can run  on  more  operating  systems  than  perhaps  any  other 
interpreter. Moreover,  carefully written  application code can  share much of 
this  portability.  Python  provides  a great  array  of  abstractions  that  do  just 
enough to hide platform differences while allowing the programmer to use the 
services of specific platforms when necessary.  
When an application requires access to facilities or libraries that Python does 
not provide, Python also makes it easy to add extensions that take advantage 
of these additional facilities. Additional modules can be created (usually in C 
or C++, but other languages can be used as well) that allow Python code to 
call on external facilities efficiently.  
Powerful but accessible object-orientation  
At one  time,  it  was  common  to  hear about how object-oriented  programming (OOP) 
would solve most of the technical problems programmers had to deal with in their code. 
Of course, programmers knew better, pushed back, and turned the concepts into useful 
tools that could be applied when appropriate (though 
how
and 
when
it should be applied 
may always be the subject of debate). Unfortunately, many languages that have strong 
support for OOP are either very tedious to work with (such as C++ or, to a lesser extent, 
Java), or they have not been as widely accepted for general use (such as Eiffel).  
Python is different. The language supports object orientation without much of 
the syntactic overhead found in many widely used object-oriented languages, 
making it very easy to define new object types. Unlike many other languages, 
Python is highly polymorphic; interfaces are  defined in much  less stringent 
ways than in languages such as C++ and Java. This makes it easy to create 
useful objects without having to write code that exists only to conform to an 
interface, but that will not actually be used in a particular application. When 
combined with the excellent advantage taken by Python's standard library of 
.NET PDF Document Viewing, Annotation, Conversion & Processing
Allow to create digital signature. Annotate & Comment. Add, insert PDF native annotations to PDF file. Edit, update, delete PDF annotations from PDF file. Print.
pdf to word converter sign in; adding a signature to a pdf
GIF to PDF Converter | Convert GIF to PDF, Convert PDF to GIF
PDF files to GIF images with high quality. It can be functioned as an integrated component without the use of external applications & Adobe Acrobat Reader.
add signature field to pdf; create signature from pdf
IT-SC book 
22 
 variety  of  common  interfaces,  the  value  of  creating  reusable  objects  is 
easily  recognized,  all  while  the  ease  of  implementing  useful  interfaces  is 
maintained.  
1.3.1 Python Tools for XML 
Three major packages provide Python tools for working with XML. These are, from the most 
commonly used to the largest:  
The Python standard library 
PyXML, produced by the Python XML Special Interest Group 
4Suite, provided by Fourthought, Inc. 
The Python standard library provides a minimal but useful set of interfaces to work with XML, 
including an interface to the popular Expat XML parser, an implementation of the lightweight 
Simple API for XML (SAX), and a basic implementation of the core Document Object Model 
(DOM).  The  DOM  implementation  supports  Level  1  and  much  of  Level  2  of  the  DOM 
specification from the W3C, but does not implement most of the optional features. The material 
in the standard library was drawn from material originally in the PyXML package, and additional 
material was contributed by leading Python XML developers.  
PyXML is a more feature-laden package; it extends the standard library with additional XML 
parsers, has a much more substantial DOM implementation (including more optional features), 
has adapters to allow more parsers to support the SAX interface, XPath expression parsing and 
evaluation,  XSLT  transformations,  and  a  variety  of  other  helper  modules.  The  package  is 
maintained as a community effort by many of the most active Python/XML programmers.  
4Suite is not a superset of the other packages, but is intended to be used in addition to PyXML. It 
offers additional DOM implementations tailored for different applications, support for the XLink 
and XPointer specifications, and tools for working with Resource Description Framework (RDF) 
data.  
These are the packages used throughout the book; see 
Appendix A
for  more information on 
obtaining and installing them. Still more are available; see 
Appendix F
for brief descriptions of 
several of these and references to more information online.  
1.3.2 The SAX and DOM APIs 
The two most basic and broadly used APIs to XML data are the SAX and DOM interfaces. These 
interfaces  differ  substantially;  learning  to  determine  which  of  these  is  appropriate  for  your 
application is an important step to learn.  
SAX defines a relatively low-level interface that is easy for XML parsers to support, but requires 
the  application  programmer  to  manage  more  details  of  using  the  information  in  the  XML 
documents and performing operations on it. It offers the advantage of low overhead: no large data 
structures are constructed unless the application  itself actually needs  them.  This allows  many 
forms  of processing  to proceed much more  quickly than could occur if  more overhead were 
required, and much larger documents can be processed efficiently. It achieves this by being an 
event-oriented
interface; using SAX is more like processing user-input events in a graphical 
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
PDF to Word Converter has accurate output, and PDF to Word Converter doesn't need the support of Adobe Acrobat & Microsoft Word.
add signature to pdf document; add signature to preview pdf
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Different from other image converters, users do not need to load Adobe Acrobat or any other print drivers when they use DICOM to PDF Converter.
add signature to pdf acrobat reader; add signature pdf
IT-SC book 
23
user interface than manipulating a pre-constructed data structure. So how do you get "events" 
from an XML parser, and what kind of events might there be?  
SAX defines a number of handler interfaces that your application can implement to receive events. 
The methods of these objects are called when the appropriate events are encountered in the XML 
document being parsed; each method can be thought of as the actual event, which fits well with 
object-oriented approaches to parsing. Events are categorized as content, document type, lexical, 
and error events; each category of events is handled using a distinct interface. The application can 
specify exactly which categories of events it is interested in receiving by providing the parser 
with the appropriate handlers and omitting those it does not need. Python's XML support provides 
base classes that allow you to implement only the methods you're interested in, just inheriting do-
nothing methods for events you don't need.  
The most commonly used events are the content-related events, of which the most important are 
startElement
characters
, and 
endElement
. We look at SAX in depth in 
Chapter 3
, but 
now let's take a quick look at how we might use SAX to extract some useful information from a 
document. We'll use a simple document; it's easy to see how this would extend to something more 
complex. The document is shown here:  
<catalog> 
<book isbn="1-56592-724-9"> 
<title>The Cathedral &amp; the Bazaar</title> 
<author>Eric S. Raymond</author> 
</book> 
<book isbn="1-56592-051-1"> 
<title>Making TeX Work</title> 
<author>Norman Walsh</author> 
</book> 
<!-- imagine more entries here... --> 
</catalog> 
If we want to create a dictionary that maps the ISBN numbers given in the 
isbn
attribute of the 
book
elements to the titles of the books (the content of the 
title
elements), we would create a 
content handler (as shown in 
Example 1-1
) that looks at the three events listed previously.  
Example 1-1. bookhandler.py  
import xml.sax.handler 
class BookHandler(xml.sax.handler.ContentHandler): 
TIFF to PDF Converter | Convert TIFF to PDF, Convert PDF to TIFF
PDF to TIFF Converter doesn't require other third-party such as Adobe Acrobat. PDF to TIFF Converter can create the output TIFF image with 68-1024 dpi.
add a signature to a pdf file; add signature to pdf preview
IT-SC book 
24 
def __init__(self): 
self.inTitle = 0 
self.mapping = {} 
def startElement(self, name, attributes): 
if name == "book": 
self.buffer = "" 
self.isbn = attributes["isbn"] 
elif name == "title": 
self.inTitle = 1 
def characters(self, data): 
if self.inTitle: 
self.buffer += data 
def endElement(self, name): 
if name == "title": 
self.inTitle = 0 
self.mapping[self.isbn] = self.buffer 
Extracting  the  information  we're  looking  for  is  now  trivial.  If  the  code  above  is  in 
bookhandler.py
and our sample document is in 
books.xml
, we could do this in an interactive 
session:  
>>> import xml.sax 
>>> import bookhandler 
>>> import pprint 
>>>  
>>> parser = xml.sax.make_parser(  ) 
>>> handler = bookhandler.BookHandler(  ) 
>>> parser.setContentHandler(handler) 
IT-SC book 
25
>>> parser.parse("books.xml") 
>>> pprint.pprint(handler.mapping) 
{u'1-56592-051-1': u'Making TeX Work', 
u'1-56592-724-9': u'The Cathedral & the Bazaar'} 
For reference material on the handler object methods, refer to 
Appendix C
.  
The DOM is quite the opposite of SAX. SAX offers a very small window of view that passes 
over the input document, relying on the application to infer the whole; the DOM gives the whole 
document  to  the  application,  which  must  then  extract  the  finer  details  for  itself.  Instead  of 
reporting individual events to the application as the parser handles the corresponding syntax in 
the  document,  the  application  creates  an  object  that  represents  the  entire  document  as  a 
hierarchical structure. Although there is no requirement that the document be completely parsed 
and stored in memory when the object is provided to the application, most implementations work 
that way for simplicity. Some implementations avoid this; it is certainly possible to create a DOM 
implementation that parses the document lazily or uses some kind of persistent storage to keep 
the parsed document instead of an in-memory structure.  
The DOM provides objects called nodes that represent parts of a document to the application. 
There are several types of nodes, each used for a different kind of construct. It is important to 
understand that the nodes of the DOM do not directly correspond to SAX events, although many 
are similar. The easiest way to see the difference is to look at how elements and their content are 
represented in both APIs. In  SAX,  an element is represented by start and  end events, and its 
content  is  represented by all the  events  that come  between  the start and  the end. The  DOM 
provides a  single  object that  represents  the  element,  and  it  provides  methods  that allow  the 
application to get the child nodes that represent the content of the element. Different node types 
are provided for elements, text, and just about everything else that can exist in an XML document.  
We go into more detail and see some extended examples using the DOM in 
Chapter 4
, and a 
detailed reference to the DOM API is given in 
Appendix D
. For a quick taste of the DOM, let's 
write a snippet of code that does the same thing we do with SAX in 
Example 1-1
, but using the 
basic DOM implementation from the Python standard library, as shown in 
Example 1-2
 
Example 1-2. dombook.py  
import pprint 
import xml.dom.minidom 
from xml.dom.minidom import Node 
doc = xml.dom.minidom.parse("books.xml") 
mapping = {} 
IT-SC book 
26 
for node in doc.getElementsByTagName("book"): 
isbn = node.getAttribute("isbn") 
L = node.getElementsByTagName("title") 
for node2 in L: 
title = "" 
for node3 in node2.childNodes: 
if node3.nodeType == Node.TEXT_NODE: 
title += node3.data 
mapping[isbn] = title 
# mapping now has the same value as in the SAX example: 
pprint.pprint(mapping) 
It should be clear that we're dealing with something very different here! While there's about the 
same  amount  of  code  in  the  DOM  example,  it  can  be  very  difficult  to  develop  reusable 
components, while experience with SAX often points the way to reusable components with only a 
small bit of refactoring.  It  is  possible  to  reuse DOM  code, but the  mindset  required  is  very 
different.  What the  DOM  provides  to  compensate  is that  a  document  can  be manipulated at 
arbitrary locations with full knowledge of the complete document, and the document contents can 
be extracted in different ways by different parts of an application without having to parse the 
document more than once. For some applications, this proves to be a highly motivating reason to 
use the DOM instead of SAX.  
1.3.3 More Ways to Extract Information 
SAX and the DOM give us some powerful tools for working with XML, but they clearly require a 
lot of code and attention to detail to use effectively in a large application. In both cases, working 
with complex data requires a great deal of work just to extract the interesting bits from the XML 
documents  that  contain the  data.  Now, what sorts  of  tools  would  we normally  turn to when 
dealing with complex data sets? Two that come to mind are higher-level abstractions (such as 
APIs that do more work, and specialized task-oriented languages), and preprocessing techniques 
(transforming data from one form to another more suitable to the task at hand). Fortunately, both 
of these are available to us when working with XML from Python.  
When an XML user wants to specify a portion of a document based on possibly complex criteria, 
she uses a language which lets her write the specification concisely; that language is called the 
XML Path Language, or XPath. Support for XPath is available in the 4Suite package, and has 
recently been added to the PyXML package as well. Using XPath, a query can be written that 
selects nodes from a DOM tree based on the element names, attribute values, textual content, and 
IT-SC book 
27
relationships between the nodes. We cover XPath in some detail, including how to use it with a 
DOM tree in Python, in 
Chapter 5
.  
Other times, what we'd really like is a new document that either contains less information or 
arranges it very differently. For this, we need a way to specify a transformation of a document 
that generates another document. This is provided by XML Stylesheet Language Transformations 
(XSLT). Originally developed as part of a new specification for stylesheets, XSLT is an XML-
based language that is used to define transformations from XML to other formats. XSLT is most 
commonly used with XML or HTML as the output format. 
Chapter 6
describes this language 
and shows how to use it in Python.  
1.4 What Can We Do with It? 
Now that we've looked at how we can use XML with Python, we need to look at how we can 
apply our knowledge of XML and Python to real applications. In the Internet age, this means 
widely distributed systems operating across the Internet.  
There's a lot to working with the Internet beyond XML and the CGI programming done in many 
of the examples in the book. In case you're not already familiar with this topic, we include an 
introduction to the facilities in the Python standard library that help create clients and servers for 
the Internet in 
Chapter 8
. We review  how to retrieve data  from remote servers, and how to 
submit form-based requests programmatically and read the result. We then learn to build custom 
web servers that respond to HTTP requests, allowing us to build servers that do exactly what we 
need them to.  
With these skills under our hat, we proceed to look at the emerging world of "web services." 
Chapter 9
describes what we mean by web services and introduces the specifications coming out 
in that area. We look at two packages that allow us to use SOAP to call on web services and 
demonstrate how to create one in Python.  
In Chapter 10
, we pull together much of what we've learned with an extended example that 
demonstrates how it all works together. Using XML as a communications medium, we are able to 
build an application that uses a variety of technologies and operates in diverse environments.  
IT-SC book 
28 
Chapter 2. XML Fundamentals 
XML is  not  new!  XML,  the  Extensible Markup  Language,  began  development  in  1996  and 
became an official World Wide Web Consortium (W3C) standard in 1998. XML is derived from 
the Standard Generalized Markup Language (SGML), which has been around for a great while. 
SGML has long been used as a means of document management, and is the parent of HTML. 
XML,  on  the  other  hand,  is  an  outgrowth  of  these  earlier  markup  languages  intended  for 
information sharing on the Internet. While HTML is effective for communicating how a page 
should look inside a web browser, XML speaks more to how information should be structured or 
used between or among applications (including web browsers) running on the Internet.  
2.1 XML Structure in a Nutshell 
The  basic  structure  of  an  XML  document  is  simple.  Most  can  be  reduced  to  a  few  simple 
components. Consider the following:  
<?xml version="1.0"?> 
<PurchaseOrder> 
<account refnum="2390094"/> 
<item sku="33-993933" qty="4"> 
<name>Potato Smasher</name> 
<description>Smash Potatoes like never before.</description> 
</item> 
</PurchaseOrder> 
In this example, the first line, starting with the 
<?
characters, is the 
XML declaration
. It states 
which  version  of  XML  is  being  used  and  can  also  include  information  about  the  character 
encoding  of  the  document.  The  text  starting  with 
<PurchaseOrder>
and  ending  with 
</PurchaseOrder>
is an XML 
element
. An element must have an opening and closing 
tag
or the opening tag must end with the characters 
/>
if it is to be empty. The 
account
element 
shown here is an example of an 
empty
element that ends with a 
/>
. The 
item
element opens, 
contains two other elements, and then closes. The 
sku="33-993933"
expression is an 
attribute
named 
sku
with  its  value 
33-993933
in quotes. An element can have as many attributes as 
needed.  Both  the 
name
and 
description
elements  are  followed  by  character  data  or  text. 
Finally, the elements are closed and the document terminates.  
In the remainder of this chapter, we walk through the relevant parts of the XML specification, 
highlighting the most  important items for you to be aware of as you embark on coding with 
Python and XML.  
2.2 Document Types and Schemas 
Documents you may be interested
Documents you may be interested