convert pdf to image asp.net c# : Create secure pdf Library software class asp.net winforms html ajax O'Reilly%20-%20Python%20Cookbook14-part1439

3.17 Converting Between Characters and Values 
Credit: Luther Blissett 
3.17.1 Problem 
You need to turn a character into its numeric ASCII (ISO) or Unicode code, and vice versa.  
3.17.2 Solution 
That's what the built-in functions 
ord
and 
chr
are for:  
>>> print ord('a') 
97 
>>> print chr(97) 
a 
The built-in function 
ord
also accepts as an argument a Unicode string of length one, in which 
case it returns a Unicode code, up to 65536. To make a Unicode string of length one from a 
numeric Unicode code, use the built-in function 
unichr
:  
>>> print ord(u'u2020') 
8224 
>>> print unichr(8224) 
u' ' 
3.17.3 Discussion 
It's a mundane task, to be sure, but it is sometimes useful to turn a character (which in Python just 
means a string of length one) into its ASCII (ISO) or Unicode code, and vice versa. The built-in 
functions 
ord
chr
, and 
unichr
cover all the related needs. Of course, they're quite suitable 
with the built-in function 
map
:  
>>> print map(ord, 'ciao') 
[99, 105, 97, 111] 
To build a string from a list of character codes, you must use both 
map
and 
''.join
:  
>>> print ''.join(map(chr, range(97, 100))) 
abc 
3.17.4 See Also 
Documentation for the built-in functions 
chr
ord
, and 
unichr
in the Library Reference.  
Create secure pdf - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
change security settings pdf; create secure pdf
Create secure pdf - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
decrypt pdf file online; convert secure webpage to pdf
3.18 Converting Between Unicode and Plain Strings 
Credit: David Ascher, Paul Prescod 
3.18.1 Problem 
You need to deal with data that doesn't fit in the ASCII character set.  
3.18.2 Solution 
Unicode strings can be encoded in plain strings in a variety of ways, according to whichever 
encoding you choose:  
# Convert Unicode to plain Python string: "encode" 
unicodestring = u"Hello world" 
utf8string = unicodestring.encode("utf-8") 
asciistring = unicodestring.encode("ascii") 
isostring = unicodestring.encode("ISO-8859-1") 
utf16string = unicodestring.encode("utf-16") 
# Convert plain Python string to Unicode: "decode" 
plainstring1 = unicode(utf8string, "utf-8") 
plainstring2 = unicode(asciistring, "ascii") 
plainstring3 = unicode(isostring, "ISO-8859-1") 
plainstring4 = unicode(utf16string, "utf-16") 
assert 
plainstring1==plainstring2==plainstring3==plainstring4 
3.18.3 Discussion 
If you find yourself dealing with text that contains non-ASCII characters, you have to learn about 
Unicode—what it is, how it works, and how Python uses it.  
Unicode is a big topic. Luckily, you don't need to know everything about Unicode to be able to 
solve real-world problems with it: a few basic bits of knowledge are enough. First, you must 
understand the difference between bytes and characters. In older, ASCII-centric languages and 
environments, bytes and characters are treated as the same thing. Since a byte can hold up to 256 
values, these environments are limited to 256 characters. Unicode, on the other hand, has tens of 
thousands of characters. That means that each Unicode character takes more than one byte, so you 
need to make the distinction between characters and bytes.  
Standard Python strings are really byte strings, and a Python character is really a byte. Other terms 
for the standard Python type are "8-bit string" and "plain string." In this recipe we will call them 
byte strings, to remind you of their byte-orientedness.  
Conversely, a Python Unicode character is an abstract object big enough to hold the character, 
analogous to Python's long integers. You don't have to worry about the internal representation; the 
representation of Unicode characters becomes an issue only when you are trying to send them to 
some byte-oriented function, such as the 
write
method for files or the 
send
method for 
network sockets. At that point, you must choose how to represent the characters as bytes. 
Converting from Unicode to a byte string is called encoding the string. Similarly, when you load 
C# Create PDF Library SDK to convert PDF from other file formats
& thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry-standard PDF document file.
change security settings on pdf; change pdf security settings reader
C# HTML5 PDF Viewer SDK to view, annotate, create and convert PDF
NET HTML5 PDF Viewer enable users to view create PDF from multiple PDF Editor also provides C#.NET users secure solutions for PDF document protection
pdf secure; change security settings pdf reader
Unicode strings from a file, socket, or other byte-oriented object, you need to decode the strings 
from bytes to characters.  
There are many ways of converting Unicode objects to byte strings, each of which is called an 
encoding. For a variety of historical, political, and technical reasons, there is no one "right" 
encoding. Every encoding has a case-insensitive name, and that name is passed to the decode 
method as a parameter. Here are a few you should know about:  
· 
The UTF-8 encoding can handle any Unicode character. It is also backward compatible 
with ASCII, so a pure ASCII file can also be considered a UTF-8 file, and a UTF-8 file 
that happens to use only ASCII characters is identical to an ASCII file with the same 
characters. This property makes UTF-8 very backward-compatible, especially with older 
Unix tools. UTF-8 is far and away the dominant encoding on Unix. It's primary weakness 
is that it is fairly inefficient for Eastern texts.  
· 
The UTF-16 encoding is favored by Microsoft operating systems and the Java 
environment. It is less efficient for Western languages but more efficient for Eastern ones. 
A variant of UTF-16 is sometimes known as UCS-2.  
· 
The ISO-8859 series of encodings are 256-character ASCII supersets. They cannot 
support all of the Unicode characters; they can support only some particular language or 
family of languages. ISO-8859-1, also known as Latin-1, covers most Western European 
and African languages, but not Arabic. ISO-8859-2, also known as Latin-2, covers many 
Eastern European languages such as Hungarian and Polish.  
If you want to be able to encode all Unicode characters, you probably want to use UTF-8. You 
will probably need to deal with the other encodings only when you are handed data in those 
encodings created by some other application.  
3.18.4 See Also 
Unicode is a huge topic, but a recommended book is Unicode: A Primer, by Tony Graham 
(Hungry Minds, Inc.)—details are available at http://www.menteith.com/unicode/primer/
.  
C# PDF Library SDK to view, edit, convert, process PDF file for C#
XDoc.PDF SDK provides users secure methods to protect PDF added to a specific location on PDF file page. In addition, you can easily create, modify, and delete
change pdf security settings; create pdf security
C# Word - Word Creating in C#.NET
Word SDK for .NET, is a robust & thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry
pdf password unlock; pdf file security
3.19 Printing Unicode Characters to Standard Output 
Credit: David Ascher 
3.19.1 Problem 
You want to print Unicode strings to standard output (e.g., for debugging), but they don't fit in the 
default encoding.  
3.19.2 Solution 
Wrap the 
stdout
stream with a converter, using the 
codecs
module:  
import codecs, sys 
sys.stdout = codecs.lookup('iso8859-1')[-1](sys.stdout) 
3.19.3 Discussion 
Unicode strings live in a large space, big enough for all of the characters in every language 
worldwide, but thankfully the internal representation of Unicode strings is irrelevant for users of 
Unicode. Alas, a file stream, such as 
sys.stdout
, deals with bytes and has an encoding 
associated with it. You can change the default encoding that is used for new files by modifying the 
site
module. That, however, requires changing your entire Python installation, which is likely 
to confuse other applications that may expect the encoding you originally configured Python to 
use (typically ASCII). This recipe rebinds 
sys.stdout
to be a stream that expects Unicode 
input and outputs it in ISO8859-1 (also known as Latin-1). This doesn't change the encoding of 
any previous references to 
sys.stdout
, as illustrated here. First, we keep a reference to the 
original, ASCII-encoded 
stdout
:  
>>> old = sys.stdout 
Then we create a Unicode string that wouldn't go through 
stdout
normally:  
>>> char = u"\N{GREEK CAPITAL LETTER GAMMA}"  # a character 
that doesn't fit in ASCII 
>>> print char 
Traceback (most recent call last): 
File "<stdin>", line 1, in ? 
UnicodeError: ASCII encoding error: ordinal not in range(128) 
Now we wrap 
stdout
in the 
codecs
stream writer for UTF-8, a much richer encoding, rebind 
sys.stdout
to it, and try again:  
>>> sys.stdout = codecs.lookup('utf-8')[-1](sys.stdout) 
>>> print char 
3.19.4 See Also 
Documentation for the 
codecs
and 
site
modules and 
setdefaultencoding
in 
sys
in 
the Library Reference.  
C# PowerPoint - PowerPoint Creating in C#.NET
SDK for .NET, is a robust & thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry
pdf security password; copy text from encrypted pdf
C# Word - Word Create or Build in C#.NET
& thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry Create Word From PDF.
create encrypted pdf; decrypt pdf without password
3.20 Dispatching Based on Pattern Matches 
Credit: Michael Robin 
3.20.1 Problem 
You need to use regular expressions to match strings and then automatically call functions with 
arguments based on the matched strings.  
3.20.2 Solution 
Once again, a class offers a good way to package together some state and some behavior:  
import re 
class Dispatcher: 
def _dispatch(self, cmdList, str): 
""" Find a match for str in the cmdList and call the 
associated 
method with arguments that are the matching 
grouped subexpressions 
from the regex. 
""" 
for comment, pattern, command in cmdList: 
found = pattern.match(str)   # or, 
use .search(  ) 
if found: return command(self, 
*found.groups(  )) 
def runCommand(self, cmd): 
self._dispatch(Commands, cmd) 
# example methods 
def cmd1(self, num, name): 
print "The number for %s is %d" % (name, int(num)) 
return 42 
def cmd2(self, partnum): 
print "Widget serial #: %d" % int(partnum) 
Commands = [ 
[ 'Number-to-name correspondence', 
r'X (?P<num>\d),(?P<name>.*)$', 
Dispatcher.cmd1], 
[ 'Extract Widget part-number', 
r'Widget (?P<partnum>.*)$', 
Dispatcher.cmd2], 
RasterEdge.com General FAQs for Products
not the product end user, please copy and email the secure download link are dedicated to provide powerful & profession imaging controls, PDF document, image
decrypt pdf online; decrypt a pdf file online
XDoc.HTML5 Viewer for .NET, All Mature Features Introductions
for .NET allows .NET developers to search text-based documents, like PDF, Microsoft Office show or hide control for text selecting in order to secure your web
decrypt a pdf; pdf password encryption
# Prepare the Commands list for execution by compiling each 
re for cmd in Commands: 
try: 
cmd[1] = re.compile( cmd[1] ) 
except: 
print "Bad pattern for %s: %s" % ( cmd[0], cmd[1] ) 
3.20.3 Discussion 
In Python, it's generally best to compile regular expressions into 
re
objects. The 
re
module does 
some caching of string-form regular expressions that you use directly, but it's still better to make 
sure that regular expressions are not needlessly recompiled. The string form is still available as 
r.pattern
for any compiled 
re
object 
r
, anyway, should you need it (e.g., for 
debugging/logging purposes).  
You can use regular expressions to match strings (or search into strings) and automatically call 
appropriate functions, passing as arguments substrings of the matched string that correspond to the 
groups of the regular expression.  
This recipe exemplifies one approach to this solution. The idea is that:  
r = self.runCommand("X 36,Mike") 
automatically calls: 
cmd1(self, "36", "Mike") 
and binds the variable 
r
to 
42
, the result of 
cmd1
.  
This specific example might be best approached with direct string manipulation (testing 
str[0]
then using the 
split
method of strings), but regular expressions let you handle much more 
complicated cases with nearly equal ease.  
An idiomatic Pythonic approach is to put each pattern to be compiled directly in the structure to be 
created at load-time. For example:  
Cmds = ( (re.compile(r"^pa(t)t1$"), fn), ... ) 
This is simple, if you don't require any special processing, but I think it's a little prettier to avoid 
including code in data-structure initializers.  
3.20.4 See Also 
Documentation for the 
re
module and regular-expression objects in the Library Reference.  
C# Excel - Excel Creating in C#.NET
SDK for .NET, is a robust & thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry
pdf security settings; copy text from locked pdf
VB.NET Word: VB Tutorial to Convert Word to Other Formats in .NET
Word converting assembly toolkit also allows developers to create a fully platforms, then converting Word to a more secure document format PDF will be
decrypt pdf file; add security to pdf file
3.21 Evaluating Code Inside Strings 
Credit: Joonas Paalasmaa 
3.21.1 Problem 
You have a string that contains embedded Python expressions, and you need to copy the string 
while evaluating those expressions.  
3.21.2 Solution 
This recipe's trick is to use the 
%
string-formatting operator's named-values variant. That variant 
normally takes a dictionary as the righthand operand, but in fact it can take any mapping, so we 
just prepare a rather special mapping for the recipe's purpose:  
class Eval: 
""" mapping that does expression evaluation when asked 
to fetch an item """ 
def _ _getitem_ _(self, key): 
return eval(key) 
Now we can perform feats such as: 
>>> number = 20 
>>> text = "python" 
>>> print "%(text.capitalize())s %(number/9.0).1f rules!" % 
Eval(  ) 
Python 2.2 rules! 
3.21.3 Discussion 
This recipe can be seen as a templating task, akin to Recipe 3.22
and Recipe 3.23
, but it is 
substantially simpler, because it needs to handle only embedded expressions, not statements. 
However, because the solution is so much simpler and faster than the general templating ones, it's 
better to think of this as a totally separate task.  
In Python, the 
%
operator of strings is typically used for normal formatting. The values to be 
interpolated in the string are the items of the righthand side, which is either a tuple, for unnamed-
value formatting, or a mapping, for named-value formatting (where format items have forms such 
as 
%(name)s
). The mapping is often obtained by functions such as the built-in 
vars
, which 
returns a dictionary that represents the current status of local variables.  
Named-value formatting is actually much more flexible. For each name string in the format, which 
is enclosed in parentheses after the 
%
character that denotes the start of a format item in the format 
string, Python calls the get-item method of the righthand-side mapping (e.g., the special method 
_getitem_ _
, when the righthand side is an instance object). That method can perform the 
necessary computation. The recipe shows off this possibility by simply delegating item-fetching to 
the built-in function 
eval
, which evaluates the name as an expression. This can be very useful in 
practice, but as presented in the solution, it's limited to accessing global variables of the module in 
which the 
Eval
class is itself defined. That makes it unwieldy for most practical purposes.  
This problem is easily fixed, of course, because the 
sys._getframe
function (in Python 2.1 
and later) makes it easy to learn about your caller's local and global variables. So, you can tailor 
the evaluation environment:  
import sys 
class Evalx: 
def _ _init_ _(self, locals=None, globals=None): 
if locals is None: self.locals = 
sys._getframe(1).f_locals 
else: self.locals = locals 
if globals is None: self.globals = 
sys._getframe(1).f_globals 
else: self.globals = globals 
def _ _getitem_ _(self, name): 
return eval(name, self.globals, self.locals) 
See Recipe 14.9
for a way to get the same functionality in other, older versions of Python.  
Any instance of the 
Evalx
class can now be used for expression evaluation, either with 
explicitly specified namespaces or, by default, with the local and global namespaces of the 
function that instantiated it.  
3.21.4 See Also 
Recipe 3.22
Recipe 3.23
, and Recipe 14.9
.  
3.22 Replacing Python Code with the Results of Executing 
That Code 
Credit: Joel Gould 
3.22.1 Problem 
You have a template string that may include embedded Python code, and you need a copy of the 
template in which any embedded Python code is replaced by the results of executing that code.  
3.22.2 Solution 
This recipe exploits the ability of the standard function 
re.sub
to call a user-supplied 
replacement function for each match and to substitute the matched substring with the replacement 
function's result:  
import re 
import sys 
import string 
def runPythonCode(data, global_dict={}, local_dict=None, 
errorLogger=None): 
""" Main entry point to the replcode module """ 
# Encapsulate evaluation state and error logging into an 
instance: 
eval_state = EvalState(global_dict, local_dict, 
errorLogger) 
# Execute statements enclosed in [!! .. !!]; statements 
may be nested by 
# enclosing them in [1!! .. !!1], [2!! .. !!2], and so 
on: 
data = 
re.sub(r'(?s)\[(?P<num>\d?)!!(?P<code>.+?)!!(?P=num)\]', 
eval_state.exec_python, data) 
# Evaluate expressions enclosed in [?? .. ??]: 
data = re.sub(r'(?s)\[\?\?(?P<code>.+?)\?\?\]', 
eval_state.eval_python, data) 
return data 
class EvalState: 
""" Encapsulate evaluation state, expose methods to 
execute/evaluate """ 
def _ _init_ _(self, global_dict, local_dict, 
errorLogger): 
self.global_dict = global_dict 
self.local_dict = local_dict 
if errorLogger: 
self.errorLogger = errorLogger 
else: 
# Default error "logging" writes error messages 
to sys.stdout 
self.errorLogger = sys.stdout.write 
# Prime the global dictionary with a few needed 
entries: 
self.global_dict['OUTPUT'] = OUTPUT 
self.global_dict['sys'] = sys 
self.global_dict['string'] = string 
self.global_dict['_ _builtins_ _'] = _ _builtins_ _ 
def exec_python(self, result): 
""" Called from the 1st re.sub in runPythonCode for 
each block of 
embedded statements. Method's result is OUTPUT_TEXT 
(see also the OUTPUT 
function later in the recipe). """ 
# Replace tabs with four spaces; remove first line's 
indent from all lines 
code = result.group('code') 
code = string.replace(code, '\t', '    ') 
result2 = re.search(r'(?P<prefix>\n[ ]*)[#a-zA-Z0-
9''"]', code) 
if not result2: 
raise ParsingError, 'Invalid template code 
expression: ' + code 
code = string.replace(code, result2.group('prefix'), 
'\n') 
code = code + '\n' 
try: 
self.global_dict['OUTPUT_TEXT'] = '' 
if self.local_dict: 
exec code in self.global_dict, 
self.local_dict 
else: 
exec code in self.global_dict 
return self.global_dict['OUTPUT_TEXT'] 
except: 
self.errorLogger('\n---- Error parsing 
statements: ----\n') 
self.errorLogger(code) 
self.errorLogger('\n------------------------\n') 
raise 
def eval_python(self, result): 
""" Called from the 2nd re.sub in runPythonCode for 
each embedded 
expression. The method's result is the expr's value 
as a string. """ 
Documents you may be interested
Documents you may be interested