convert pdf to image c# ghostscript : Add security to pdf document software Library cloud windows .net web page class O'Reilly%20-%20Python%20Cookbook54-part1483

14.6 Starting the Debugger Automatically After an 
Uncaught Exception 
Credit: Thomas Heller 
14.6.1 Problem 
When running a script, Python normally responds to uncaught exceptions by printing a traceback 
and terminating execution, but you would prefer to automatically enter an interactive debugger in 
such cases when feasible.  
14.6.2 Solution 
By setting 
sys.excepthook
, you can control what happens after uncaught exceptions:  
# code snippet to be included in sitecustomize.py 
# Needs Python 2.1 or later! 
import sys 
def info(type, value, tb): 
if hasattr(sys, 'ps1') or not sys.stderr.isatty(  ): 
# You are in interactive mode or don't have a tty-like 
# device, so call the default hook 
sys._ _excepthook_ _(type, value, tb) 
else: 
import traceback, pdb 
# You are NOT in interactive mode; print the 
exception... 
traceback.print_exception(type, value, tb) 
print 
# ...then start the debugger in post-mortem mode 
pdb.pm(  ) 
sys.excepthook = info 
14.6.3 Discussion 
When Python runs a script and an uncaught exception is raised, a traceback is printed to standard 
error, and the script is terminated. Python 2.1 has introduced 
sys.excepthook
, which can be 
used to override the handling of uncaught exceptions. This lets you automatically start the 
debugger on an unexpected exception when Python is not running in interactive mode but a tty-
like device is available.  
The code in this recipe is meant to be included in sitecustomize.py, which is automatically 
imported by Python at startup. The debugger is started only when Python is run in noninteractive 
mode, and only when a tty-like device is available for interactive debugging. (Thus, it is not 
started for CGI scripts, daemons, and so on; to handle such cases, see Recipe 14.3
.) If you do not 
have a sizecustomize.py file, create one and place it somewhere on your Python path (normally in 
the site-packages directory).  
A nice further extension to this recipe would be to detect if a GUI IDE is in use, and in this case, 
trigger the IDE's appropriate debugging environment rather than Python's own core pdb, which is 
Add security to pdf document - 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
pdf security password; creating secure pdf files
Add security to pdf document - 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
secure pdf remove; pdf security settings
appropriate only for text-interactive use. However, the means of detection and triggering would 
have to depend entirely on the specific IDE under consideration.  
14.6.4 See Also 
Recipe 14.3
; documentation on the 
_ _excepthook_ _
function in the 
sys
module and the 
traceback
sitecustomize
, and 
pdb
modules in the Library Reference.  
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via password by using simple VB.NET demo code. Add password to PDF. Set PDF security level.
decrypt a pdf file online; change pdf security settings reader
C# PDF Password Library: add, remove, edit PDF file password in C#
To help protect your PDF document in C# project, XDoc.PDF provides some PDF security settings. Add necessary references: RasterEdge.Imaging.Basic.dll.
add security to pdf in reader; decrypt pdf password
14.7 Logging and Tracing Across Platforms 
Credit: Luther Blissett 
14.7.1 Problem 
You have a program that needs to run on both Windows and Unix, and you want to trace and/or 
log output (typically for debugging) simply and flexibly.  
14.7.2 Solution 
You can rebind 
sys.stdout
so that 
print
statements will be logged and use a sophisticated 
class for the rebinding to ensure that auxiliary functionality such as automatic timestamping is 
done in a platform-independent way:  
# tweakable timestamper callable 
import time 
class Timestamper: 
msg_format = "%y%m%d %H%M%S", time.localtime, "%s: %s" 
def _ _call_ _(self, msg): 
tfmt, tfun, gfmt = self.msg_format 
return gfmt%(time.strftime(tfmt,tfun(  )), msg) 
# Bind name 'syslogger' to an output-to-system-log function 
(if any) 
try: import syslog 
except ImportError: 
try: import servicemanager 
except ImportError: 
# no logging available -- maybe OutputDebugString? 
try: import win32api 
except ImportError: # none, give up and use a dummy 
function 
def syslogger(msg): pass 
else: 
timestamp = Timestamper(  ) 
def syslogger(msg): 
win32api.OutputDebugString(timestamp(msg)) 
else: syslogger = servicemanager.LogInfoMsg 
else: syslogger = syslog.syslog 
class FunctionFilelikeWrapper: 
def _ _init_ _(self, func): 
self.func = func 
def write(self, msg): 
self.func(msg) 
syslogfile = FunctionFilelikeWrapper(syslogger) 
class TeeFilelikeWrapper: 
def _ _init_ _(self, *files): 
self.files = files 
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
How to improve PDF document security. If you need to add your own signatures such as logo to PDF document, you and load and save it to current PDF file.
create secure pdf online; secure pdf file
C# HTML5 Viewer: Deployment on AzureCloudService
RasterEdge.XDoc.PDF.HTML5Editor.dll. 2. Add fill extension such as validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
pdf security remover; pdf unlock
def write(self, msg): 
for f in self.files: f.write(msg) 
class FlushingWrapper: 
def _ _init_ _(self, *files): 
self.files = files 
def write(self, msg): 
for f in self.files: 
f.write(msg) 
f.flush(  ) 
def logto(*files): 
sys.stdout = TeeFilelikeWrapper(*files) 
14.7.3 Discussion 
When you write a Windows NT service, you can log information to the system log with calls to 
functions in the 
servicemanager
module. But 
servicemanager
is a peculiar module 
that lives only in the special PythonService.Exe interpreter, so it's not even available to nonservice 
programs on Windows, let alone non-Windows platforms. On Unix-like platforms, any Python 
program can do logging with the 
syslog
module, but there is no such thing on Windows.  
Another Windows possibility is 
OutputDebugString
. For this, you need to have a system 
debugger running, but it can get debug strings from multiple sources and serialize them to a log 
display window and/or file. Of course, on any platform, you can also write to a file, as long as you 
make sure the file is unbuffered. According to the Python documentation, this works only if the 
underlying C library has 
setvbuf
, or if you ensure that 
flush
is called with each 
write
(to 
avoid wondering if 
setvbuf
is there).  
Besides, I really like to use 
print
statements, because they're good for debugging. And 
sometimes, I like to see the tracing information that I'm logging for debugging purposes also 
appear on a terminal window or console (when my program has one of those, of course) in real 
time. I also like to send the information to a more permanent log (or file) for later analysis (and I 
want it timestamped, unless it's going to a logging service, such as 
syslog
, which will 
timestamp it for me).  
This might seem like a tall order, but not with Python. The module in this recipe gives you all the 
bricks you need to build the debug-oriented output you need. Most of the time, I import 
logger
then call:  
logger.logto(sys.stderr, logger.syslogfile, 
open("/tmp/mylog.txt","w")) 
(Maybe I should be more punctilious and use the 
tempfile
module to get the temporary file's 
directory instead.) But the 
logger
module also gives me all the tools for fine-tuning when I 
want them. Now, whenever I 
print
something, it goes to the terminal (standard error) if one 
exists; to the 
syslog
, if one exists (possibly 
OutputDebugString
); and to a text file in 
the temporary directory, just in case.  
When I want to call another function automatically to display something I 
print
, I wrap it in a 
logger.FunctionFilelikeWrapper
. And, of course, it's easy to tweak and customize 
this recipe, since it is so utterly simple, adding whatever other bricks I frequently use.  
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
Security PDF component download. This .NET PDF Document Add-On integrates mature PDF document page processing functions, including extracting one or more page(s
decrypt pdf without password; copy text from locked pdf
VB.NET PDF Library SDK to view, edit, convert, process PDF file
PDF Document Protection. XDoc.PDF SDK allows users to perform PDF document security settings in VB.NET program. Password, digital
change security settings pdf reader; pdf secure signature
The recipe shows how to use quite a few important Pythonic idioms: 
· 
Using 
try
/
except
around an 
import
for conditional import purposes  
· 
Using a do-nothing function that is callable without harm, rather than using 
None
, which 
you have to test for before each call  
· 
Timestamper
class that offers usable default class attributes (for such things as 
format strings) but accesses them via 
self
, so they're tweakable per instance, if needed  
· 
File-like objects that wrap other objects, such as a function or a collection of other file-
like objects.  
Some of the idioms used in this recipe are generalized or explained further in other recipes in this 
book. For example, the do-nothing function is vastly generalized and extended in the Null Object 
design pattern (see Recipe 5.24
). But seeing the various Pythonic pieces work together like this, 
albeit in a more restricted setting, can help understand them better. Besides, this recipe does make 
logging and tracing much easier and more pleasant.  
This discussion concludes with a few principles of operation. Starting from the end, the 
logto
function accepts any number of arguments, passes them to the constructor of a new instance of the 
TeeFilelikeWrapper
class, and assigns that instance as the new value of the 
sys.stdout
system variable, which is the standard output of any Python program. The 
print
statement emits what you are printing to whatever object is referenced by 
sys.stdout
, and all it asks of that object is that it expose a callable attribute (method) named 
write
, which takes a string argument. (It also requires that an attribute named 
softspace
be 
settable and gettable for 
print
's own internal purposes, but that's no problem as long as you use 
normal instance objects, since arbitrary attributes can be set and retrieved from such instances).  
The 
TeeFilelikeWrapper
class has an instance constructor that accepts an arbitrary 
sequence of files (arbitrary objects with a 
write
method, as above) and saves the sequence as 
the 
self.files
instance member. The 
write
method loops on 
self.files
, making 
identical 
write
calls on each. We could use an amusing variation on this theme by extracting 
the 
write
methods at initialization and calling them in 
write
. This has two advantages: earlier 
failure if we pass an object to 
_ _init_ _
without a 
write
method by mistake, and better 
performance by avoiding the method extraction on each 
write
call. Neither is a huge advantage, 
and a beginner might find the approach confusing, so I've stuck with the obvious approach in the 
recipe, but for completeness, here is the alternative:  
class TeeFilelikeWrapper: 
def _ _init_ _(self, *files): 
self.write_methods = [ f.write for f in files ] 
def write(self, msg): 
for w in self.write_methods: w(msg) 
The 
FlushingWrapper
class is just like 
TeeFilelikeWrapper
, but after 
write
, it 
also calls 
flush
on each of the file objects it's wrapping to ensure that output has actually 
occurred.  
The 
FunctionFilelikeWrapper
class wraps a function (actually any callable object), 
which it receives in the instance constructor, as a file-like object, translating each call to 
write
into a call to the function it wraps. The code in the recipe just before the definition of this class 
tries to determine the best function to use as 
syslogger
. The 
try
/
except
statements 
around 
import
statements ensure that we use 
syslog.syslog
on a Unix-like platform that 
supplies it, 
servicemanager.LogInfoMsg
if the current program is a Python-coded 
C# Image: C# Code to Upload TIFF File to Remote Database by Using
save the ImageUploadService file, add a web using System.Security.Cryptography; private void tsbUpload_Click profession imaging controls, PDF document, image to
create pdf security; can print pdf security
VB.NET PDF - VB.NET HTML5 PDF Viewer Deployment on IIS
place where you store XDoc.PDF.HTML5 Viewer correspond site-> Edit Permissions -> Security -> Group or user names -> Edit -> Add -> Add Everyone usersgiven
change pdf security settings; change pdf document security properties
Win32 service, 
OutputDebugString
for other Win32 programs, or nothing at all (a do-
nothing function, to be precise) if none of these conditions is satisfied.  
With 
OutputDebugString
, a 
timestamp
object is also used, specifically to ensure that a 
timestamp accompanies each message being logged (not needed if we're using a real logging 
system, be it 
syslog
or one of Win32's, since the timestamping will be done by the system). For 
this purpose, we also have a 
Timestamper
class that we instantiate. Alternatively, a simple 
timestamp
function might be defined and used, but a class has the added value of being 
tweakable. If elsewhere we need other timestamping but with a different format, or a different way 
to obtain the time, we can still use 
Timestamper
by setting an instance's value for 
msg_format
appropriately.  
14.7.4 See Also 
Recipe 5.24
for a much more generalized version of the do-nothing function; documentation for 
the 
syslog
module in the Library Reference; the manpages for 
syslog
on your system; 
documentation for 
servicemanager
and 
win32api
in 
win32all
(http://starship.python.net/crew/mhammond/win32/Downloads.html
) or ActivePython 
(http://www.activestate.com/ActivePython/
); Windows API documentation available from 
Microsoft (http://msdn.microsoft.com
).  
14.8 Determining the Name of the Current Function 
Credit: Alex Martelli 
14.8.1 Problem 
You have error messages that include the name of the function emitting them. To copy such 
messages to other functions, you have to edit them each time, unless you can automatically find 
the name of the current function.  
14.8.2 Solution 
This introspective task is easily performed with 
sys._getframe
. This function returns a 
frame object whose attribute 
f_code
is a code object and the 
co_name
attribute of that object 
is the function name:  
import sys 
this_function_name = sys._getframe(  ).f_code.co_name 
The frame and code objects also offer other useful information: 
this_line_number = sys._getframe(  ).f_lineno 
this_filename = sys._getframe(  ).f_code.co_filename 
By calling 
sys._getframe(1)
, you can get this information for the caller of the current 
function. So you can package this functionality into your own handy functions:  
def whoami(  ): 
import sys 
return sys._getframe(1).f_code.co_name 
me  = whoami(  ) 
This calls 
sys._getframe
with argument 1, because the call to 
whoami
is now frame 0. 
Similarly:  
def callersname(  ): 
import sys 
return sys._getframe(2).f_code.co_name 
him = callersname(  ) 
14.8.3 Discussion 
You want to determine the name of the currently running function—for example, to create error 
messages that don't need to be changed when copied to other functions. The function 
_getframe
function of the 
sys
module does this and much more. This recipe is inspired by 
Recipe 10.4 in the Perl Cookbook. Python's 
sys._getframe
, new in 2.1, offers information 
equivalent to (but richer than) Perl's built-in 
caller
_ _LINE_ _
, and 
_ _FILE_ _
. If 
you need this functionality for older Python releases, see Recipe 14.9
.  
14.8.4 See Also 
Recipe 14.9
for a version that works with older Python versions; documentation on the 
_getframe
method of the 
sys
module in the Library Reference; Perl Cookbook Recipe 10.4.  
14.9 Introspecting the Call Stack with Older Versions of 
Python 
Credit: Richard Philips, Christian Tismer 
14.9.1 Problem 
You need to introspect information about a function on the call stack, but you also need to 
maintain compatibility with older Python versions.  
14.9.2 Solution 
For debugging purposes, you often want to know where a function was called from or other call-
stack information. The 
_getframe
function helps. Just ensure that the following code is 
executed during your program's startup:  
import sys 
try: sys._getframe 
except AttributeError:   # We must be using some old version 
of Python, so: 
def _getframe(level=0): 
try: 1/0 
except: tb = sys.exc_info(  )[-1] 
frame = tb.tb_frame 
while level >= 0: 
frame = frame.f_back 
level = level - 1 
return frame 
sys._getframe = _getframe 
del _getframe 
Now you can use 
sys._getframe
regardless of which version of Python you are using.  
14.9.3 Discussion 
The 
sys._getframe
function, which is invaluable for introspection anywhere in the call 
stack, was introduced in Python 2.1. If you need to introspect the call stack but maintain 
compatibility with older Python versions, this recipe shows how to simulate 
sys._getframe
and inject the function's implementation in the 
sys
module, so that you can use it freely 
regardless of which version of Python you use.  
14.9.4 See Also 
Recipe 14.8
; documentation on the 
_getframe
method of the 
sys
module in the Library 
Reference.  
14.10 Debugging the Garbage-Collection Process 
Credit: Dirk Holtwick 
14.10.1 Problem 
You know that memory is leaking from your program, but you have no indication of what exactly 
is being leaked. You need more information to help you figure out where the leaks are coming 
from, so you can remove them and lighten the garbage-collection work periodically performed by 
the standard 
gc
module.  
14.10.2 Solution 
The 
gc
module lets you dig into garbage-collection issues:  
import gc 
def dump_garbage(  ): 
""" 
show us what the garbage is about 
""" 
# Force collection 
print "\nGARBAGE:" 
gc.collect(  ) 
print "\nGARBAGE OBJECTS:" 
for x in gc.garbage: 
s = str(x) 
if len(s) > 80: s = s[:77]+'...' 
print type(x),"\n  ", s 
if _ _name_ _=="_ _main_ _": 
gc.enable(  ) 
gc.set_debug(gc.DEBUG_LEAK) 
# Make a leak 
l = [] 
l.append(l) 
del l 
# show the dirt ;-) 
dump_garbage(  ) 
14.10.3 Discussion 
In addition to the normal debugging output of 
gc
, this recipe shows the garbage objects to help 
you get an idea of where the leak may be. Situations that could lead to garbage collection should 
be avoided. Most of the time, they're caused by objects that refer to themselves, or similar 
reference loops (also known as cycles).  
Once you've found where the reference loops are coming from, Python offers all the needed tools 
to remove them, particularly weak references (in the 
weakref
standard library module). But 
Documents you may be interested
Documents you may be interested