convert pdf to image c# ghostscript : Copy text from encrypted pdf control SDK platform web page wpf winforms web browser O'Reilly%20-%20Python%20Cookbook61-part1491

16.6.4 See Also 
The Extending and Embedding manual is available as part of the standard Python documentation 
set at http://www.python.org/doc/current/ext/ext.html
; documentation on the Python C API at 
http://www.python.org/doc/current/api/api.html
.  
Copy text from encrypted 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
pdf file security; change security settings pdf
Copy text from encrypted 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
pdf secure signature; create pdf security
16.7 Implementing C Function Callbacks to a Python 
Function 
Credit: Swaminathan Narayanan 
16.7.1 Problem 
You must call a C function that takes a function callback as an argument, and you want to pass a 
Python function as the callback.  
16.7.2 Solution 
For this, we must wrap the Python function in a C function to be passed as the actual C-level 
callback. For example:  
#include "python.h" 
/* the C standard library qsort function, just as an example! 
*/ 
extern void qsort(void *, size_t, size_t, int (*)(const void 
*, const void *)); 
/* static data (sigh), as we have no callback data in this 
(nasty) case */ 
static PyObject *py_compare_func = NULL; 
static int 
stub_compare_func(const void *cva, const void *cvb) 
int retvalue = 0; 
const PyObject **a = (const PyObject**)cva; 
const PyObject **b = (const PyObject**)cvb; 
// Build up the argument list... 
PyObject *arglist = Py_BuildValue("(OO)", *a, *b); 
// ...for calling the Python compare function 
PyObject *result = PyEval_CallObject(py_compare_func, 
arglist); 
if (result && PyInt_Check(result)) { 
retvalue = PyInt_AsLong(result); 
Py_XDECREF(result); 
Py_DECREF(arglist); 
return retvalue; 
static PyObject *pyqsort(PyObject *obj, PyObject *args) 
C# PDF Password Library: add, remove, edit PDF file password in C#
passwordSetting.IsExtract = true; // Copy is allowed. In this part, you will know how to change and update password for an encrypted PDF file in C# programming
change pdf document security; decrypt pdf file online
VB.NET PDF Password Library: add, remove, edit PDF file password
passwordSetting.IsExtract = True ' Copy is allowed In this part, you will know how to change and update password for an encrypted PDF file in VB.NET programming
create secure pdf; copy text from encrypted pdf
PyObject *pycompobj; 
PyObject *list; 
if (!PyArg_ParseTuple(args, "OO", &list, &pycompobj)) 
return NULL; 
// Make sure second argument is a function 
if (!PyCallable_Check(pycompobj)) { 
PyErr_SetString(PyExc_TypeError, "Need a callable 
object!"); 
} else { 
// Save the compare function. This obviously won't 
work for multithreaded 
// programs and is not even a reentrant, alas -- 
qsort's fault! 
py_compare_func = pycompobj; 
if (PyList_Check(list)) { 
int size = PyList_Size(list); 
int i; 
// Make an array of (PyObject *), because qsort 
does not know about 
// the PyList object 
PyObject **v = (PyObject **) 
malloc( sizeof(PyObject *) * size ); 
for (i=0; i<size; ++i) { 
v[i] = PyList_GetItem(list, i); 
// Increment the reference count, because 
setting the list  
// items below will decrement the reference 
count 
Py_INCREF(v[i]); 
qsort(v, size, sizeof(PyObject*), 
stub_compare_func); 
for (i=0; i<size; ++i) { 
PyList_SetItem(list, i, v[i]); 
// need not do Py_DECREF - see above 
free(v); 
Py_INCREF(Py_None); 
return Py_None; 
static PyMethodDef qsortMethods[] = { 
{ "qsort", pyqsort, METH_VARARGS }, 
{ NULL, NULL } 
}; 
_ _declspec(dllexport) void initqsort(void) { 
PyObject *m; 
m = Py_InitModule("qsort", qsortMethods); 
VB.NET Excel: Render and Convert Excel File to TIFF Image by Using
contained in the Excel needs to be encrypted, it will If you want to view or edit PDF, Word, Excel or Excel document to REImage, you can just copy following VB
pdf security settings; add security to pdf in reader
16.7.3 Discussion 
Let's say you have a function in C or C++ that takes a function callback as an argument. You want 
to call this function and pass a Python function as the callback. For example, you want to call the 
standard C library function 
qsort
on a suitably arrayized Python list and pass a Python function 
as the comparison function:  
>>> import qsort 
>>> a = [9, 3, 5, 4, 1] 
>>> def revcmp(a, b): return cmp(b, a) 
... 
>>> qsort.qsort(a, revcmp) 
>>> a 
[9, 5, 4, 3, 1] 
Of course, this is strictly for demonstration purposes, since Python's own 
sort
list method is far 
better!  
When extending Python, you may come across existing C functions that take a function callback. 
It makes sense to pass Python a function as the callback function. The trick is to have a C function 
callback call the Python function by suitably marshaling the arguments. This is done by 
stub_compare_func
in the recipe. 
Py_BuildValue
is used to pass the two Python 
objects being compared back to the Python function.  
In the case of 
qsort
, there is no user data that can be passed, which is usually the callback 
convention. This means that we have to store the Python function in a static variable and use it to 
call in the C callback. This is not an ideal situation, given that it would not work in a 
multithreaded, or otherwise reentrant, program). While there is no solution for this particular case 
(as far as I know), the usual trick is to pass the Python function as user data to the function 
callback, an approach that is reentrant and thread-safe. But the possibility of using this better 
approach depends on whether the C-level callback architecture is well-designed.  
This recipe's wrapper of 
qsort
copies the 
PyObject
pointers to a separate array that is sorted 
using the C library's 
qsort
. The pointers are then put back in the original list. The reference 
counts of the items in the list that are being replaced are decreased behind the scenes. However, 
this is okay, because we increased them beforehand. Consequently, we do not need to do a 
Py_DECREF
after setting the item in the list. Thus, this recipe also serves nicely as an example 
of a reference count handling quirk.  
16.7.4 See Also 
The Extending and Embedding manual is available as part of the standard Python documentation 
set at http://www.python.org/doc/current/ext/ext.html
; documentation on the Python C API at 
http://www.python.org/doc/current/api/api.html
; documentation on 
qsort
for your standard C 
library.  
16.8 Debugging Dynamically Loaded C Extensions with 
gdb 
Credit: Joseph VanAndel, Michael Aivazis 
16.8.1 Problem 
A dynamically loaded C/C++ Python extension is giving you trouble on Unix or a Unix-like 
platform, and you would like to use the interactive debugger gdb to find out more about what's 
wrong.  
16.8.2 Solution 
One way to find the cause of core dumps or other serious trouble with a C Python extension is to 
compile the extension source with 
-g
and then follow these steps (you may also want to 
recompile any other extensions you use, such as Numeric, with 
-g
):  
% gdb /usr/bin/python2.1 
(gdb) br _PyImport_LoadDynamicModule 
(gdb) cont   # Repeat until your extension is loaded 
(gdb) finish # to load your extension 
(gdb) br wrap_myfunction  # the entry point in your code 
(gdb) disable 1   # don't want to break for more modules 
being loaded 
(gdb) continue 
16.8.3 Discussion 
If a dynamically loaded C/C++ extension is causing Python to core dump, or causing some other 
kind of serious trouble, this recipe can help you find out the root cause by showing a technique to 
debug your extension using gdb (if you use Unix or a Unix-like platform, and gdb is your 
debugger of choice). Note that the overall concept generalizes to other debuggers with abilities 
similar to gdb's. You cannot set a break on your function all at once, because your function lives in 
a dynamic library (shared object) that isn't initially loaded. However, you can break in the 
PyImport_LoadDynamicModule
function and eventually (when your module is at long 
last loaded) get control at the debugger prompt after your module is in memory. You will be able, 
at last, to set the breakpoint you need.  
This technique works. However, if you often do this kind of thing, the process of stepping through 
all the modules, as Python loads them at startup, can easily become tedious. There's a handier 
alternative, although it's more invasive, because it requires you to modify your Python sources and 
rebuild Python from them.  
The key idea of this handier alternative is to add a do-nothing function somewhere in the body of 
code that Python loads immediately. Specifically, you can edit the Modules/main.c file to include 
one new function:  
void Py_DebugTrap(void) { } 
In whatever extension you're debugging, add a call to 
Py_DebugTrap
right where you want to 
break into the code. The 
Py_DebugTrap
symbol is immediately available when you start gdb, 
because the symbol lives in main.c. So you can immediately set a breakpoint there when you are 
at the gdb prompt, then continue. This even works in parallel under MPI.  
16.8.4 See Also 
The gdb online documentation (just type 
help
at the interactive prompt), manpages, and online 
manual (http://www.gnu.org/manual/gdb-4.17/gdb.html
).  
16.9 Debugging Memory Problems 
Credit: Will Ware 
16.9.1 Problem 
You're developing C extensions, and you experience memory problems. You suspect 
mismanagement of reference counts and want to check whether your C extension code is 
managing reference counts correctly.  
16.9.2 Solution 
To chase these problems optimally, you need to alter Python's sources and rebuild Python. 
Specifically, add this function in Objects/object.c immediately before the 
_Py_PrintReferences
function:  
void 
_Py_CountReferences(FILE *fp) 
int n; 
PyObject *op; 
for (n = 0, op = refchain._ob_next; 
op != &refchain; 
op = op->_ob_next, n += op->ob_refcnt) 
{ } 
fprintf(fp, "%d refs\n", n); 
I place in the following macros in my C extension: 
#if defined(Py_DEBUG) || defined(DEBUG) 
extern void _Py_CountReferences(FILE*); 
#define CURIOUS(x) { fprintf(stderr, _ _FILE_ _ ":%d ", _ 
_LINE_ _); x; } 
#else 
#define CURIOUS(x) 
#endif 
#define MARKER(  )        CURIOUS(fprintf(stderr, "\n")) 
#define DESCRIBE(x)     CURIOUS(fprintf(stderr, "  " #x 
"=%d\n", x)) 
#define DESCRIBE_HEX(x) CURIOUS(fprintf(stderr, "  " #x 
"=%08x\n", x)) 
#define COUNTREFS(  )     
CURIOUS(_Py_CountReferences(stderr)) 
To debug, I rebuild Python using 
make OPT="-DPy_DEBUG"
, which causes the code under 
Py_TRACE_REFS
to be built. My own makefile for my extensions does the same trick by 
including these lines:  
debug: 
make clean; make OPT="-g -DPy_DEBUG" all 
CFLAGS = $(OPT) -fpic -O2 -I/usr/local/include -
I/usr/include/python1.5 
16.9.3 Discussion 
If I'm developing C extensions and I run into memory problems, I find that the typical cause is 
mismanagement of reference counts, particularly abuses of 
Py_INCREF
and 
Py_DECREF
, as 
well as forgetfulness of the reference-count effects of functions such as 
Py_BuildValue
PyArg_ParseTuple
PyTuple/List_SetItem/GetItem
, etc. The 1.5.2 source 
code base offers some help with this (search for 
Py_TRACE_REFS
), but I found it useful to add 
this recipe's function in Objects/object.c just before 
_Py_PrintReferences
.  
Unlike 
_Py_PrintReferences
, this recipe's function will print only the total of all the 
reference counts in the system, so it can be used safely in loops that will repeat millions of times, 
whereas 
_Py_PrintReferences
would print out way too many counts to be useful. This 
can help you identify errantly wandering 
Py_INCREF
s and 
Py_DECREF
s.  
So when I suspect that one of my functions is responsible for memory problems, I liberally 
sprinkle the suspect function with calls to the 
COUNTREFS
macro. This allows me to keep track 
of exactly how many references are being created or destroyed as I go through my function. This 
is particularly useful in tight loops, in which dumb mistakes can cause reference counts to grow 
ridiculously fast. Also, reference counts that shrink too fast (overzealous use of 
Py_DECREF
can cause core dumps because the memory for objects that should still exist has been reallocated 
to new objects.  
16.9.4 See Also 
The only documentation in this case is the source code ("Use the source, Luke!").  
16.10 Using SWIG-Generated Modules in a Multithreaded 
Environment 
Credit: Joseph VanAndel, Mark Hammond 
16.10.1 Problem 
You want to use SWIG-generated modules in a multithreaded environment; therefore, the C code 
in these modules must release the Python global interpreter lock.  
16.10.2 Solution 
Use a 
typemap
for SWIG (written by Mark Hammond) as posted on comp.lang.python. It maps 
Win32 API functions that return 
BOOL
to Python functions that return 
None
, but may raise 
exceptions. The wrapped function must set the standard Windows global 
LastError
if it 
returns false (indicating that it has detected an error). The wrapping function must also 
automatically release the Python global interpreter lock for the duration of the function, and thus 
allow free multithreading.  
%typedef BOOL BOOLAPI 
%typemap(python,except) BOOLAPI { 
  Py_BEGIN_ALLOW_THREADS 
$function 
Py_END_ALLOW_THREADS 
if (!$source)  { 
$cleanup 
return PyWin_SetAPIError("$name"); 
16.10.3 Discussion 
To use multiple threads effectively, you must release the Python global interpreter lock from your 
extension C code whenever feasible. The simplest way to do this with SWIG is to use an 
except
directive, as shown in the recipe's 
typemap
. Another interesting effect of this 
typemap
is that it turns the C-oriented error-return convention (returning a 0 value and setting a 
global error indicator code) into a highly Pythonic convention (raising an exception).  
16.10.4 See Also 
SWIG and its typemaps are documented at http://www.swig.org
; Windows API documentation on 
LastError
available from Microsoft (http://msdn.microsoft.com
).  
Chapter 17. Algorithms 
Section 17.1.  Introduction
Section 17.2.  Testing if a Variable Is Defined
Section 17.3.  Evaluating Predicate Tests Across Sequences
Section 17.4.  Removing Duplicates from a Sequence
Section 17.5.  Removing Duplicates from a Sequence While Maintaining Sequence Order
Section 17.6.  Simulating the Ternary Operator in Python
Section 17.7.  Counting Items and Sorting by Incidence (Histograms)
Section 17.8.  Memoizing (Caching) the Return Values of Functions
Section 17.9.  Looking Up Words by Sound Similarity
Section 17.10.  Computing Factorials with lambda
Section 17.11.  Generating the Fibonacci Sequence
Section 17.12.  Wrapping an Unbounded Iterator to Restrict Its Output
Section 17.13.  Operating on Iterators
Section 17.14.  Rolling Dice
Section 17.15.  Implementing a First-In First-Out Container
Section 17.16.  Modeling a Priority Queue
Section 17.17.  Converting Numbers to Rationals via Farey Fractions
Section 17.18.  Evaluating a Polynomial
Section 17.19.  Module: Finding the Convex Hull of a Set of 2D Points
Section 17.20.  Module: Parsing a String into a Date/Time Object Portably
Documents you may be interested
Documents you may be interested