how to convert pdf to image using itextsharp in c# : Change security settings pdf Library software component asp.net windows html mvc Official%20Python%20Manual%20of%20Python%202.7.6%20303-part1741

index
modules |
next |
previous |
Initialization, Finalization, and Threads
Initializing and finalizing the interpreter
void 
Py_Initialize
()
Initialize the Python interpreter. In an application embedding Python, this should be
called  before  using  any  other  Python/C  API  functions;  with  the  exception  of
Py_SetProgramName()
Py_SetPythonHome()
PyEval_InitThreads()
,
PyEval_ReleaseLock()
, and 
PyEval_AcquireLock()
. This initializes the table of loaded
modules  (
sys.modules
),  and  creates  the  fundamental  modules 
__builtin__
,
__main__
and 
sys
. It also initializes the module search path (
sys.path
). It does not
set 
sys.argv
 use 
PySys_SetArgvEx()
for  that. This is a no-op when called for a
second time (without calling 
Py_Finalize()
first). There is no return value; it is a fatal
error if the initialization fails.
void 
Py_InitializeEx
(
int initsigs
)
This  function  works  like 
Py_Initialize()
if initsigs  is  1.  If initsigs  is  0,  it  skips
initialization registration of signal handlers, which might be useful when Python is
embedded.
New in version 2.4.
int 
Py_IsInitialized
()
Return true (nonzero) when the Python interpreter has been initialized, false (zero) if
not. After 
Py_Finalize()
is called, this returns false until 
Py_Initialize()
is called
again.
void 
Py_Finalize
()
Undo all initializations made by 
Py_Initialize()
and subsequent use of Python/C API
functions, and destroy all sub-interpreters (see 
Py_NewInterpreter()
below) that were
created and not yet destroyed since the last call to 
Py_Initialize()
. Ideally, this
frees all memory allocated by the Python interpreter. This is a no-op when called for a
second time (without calling 
Py_Initialize()
again first). There is no return value;
errors during finalization are ignored.
This function is provided for a number of reasons. An embedding application might
want to restart Python without having to restart the application itself. An application
that has loaded the Python interpreter from a dynamically loadable library (or DLL)
Python » Python v2.7.6 documentation » Python/C API Reference Manual »
Change security settings 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 on pdf; copy locked pdf
Change security settings 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
change pdf security settings; secure pdf
might want to free all memory allocated by Python before unloading the DLL. During a
hunt for memory leaks in an application a developer might want to free all memory
allocated by Python before exiting from the application.
Bugs and caveats: The destruction of modules and objects in modules is done in
random order; this may cause destructors (
__del__()
methods) to fail when they
depend on other objects (even functions) or modules. Dynamically loaded extension
modules loaded by Python are not unloaded. Small amounts of memory allocated by
the Python interpreter may not be freed (if you find a leak, please report it). Memory
tied up in circular references between objects is not freed. Some memory allocated by
extension modules may not be freed. Some extensions may not work properly if their
initialization routine is called more than once; this can happen if an application calls
Py_Initialize()
and 
Py_Finalize()
more than once.
Process-wide parameters
void 
Py_SetProgramName
(
char *name
)
This function should be called before 
Py_Initialize()
is called for the first time, if it is
called at all. It tells the interpreter the value of the 
argv[0]
argument to the 
main()
function of the program. This is used by 
Py_GetPath()
and some other functions
below to find the Python run-time libraries relative to the interpreter executable. The
default value is 
'python'
. The argument should point to a zero-terminated character
string  in  static  storage  whose  contents  will  not  change  for  the  duration  of  the
program’s execution. No code in the Python interpreter will change the contents of this
storage.
char* 
Py_GetProgramName
()
Return the program name set with 
Py_SetProgramName()
, or the default. The returned
string points into static storage; the caller should not modify its value.
char* 
Py_GetPrefix
()
Return  the prefix for installed platform-independent files. This is derived through a
number of complicated rules from the program name set with 
Py_SetProgramName()
and  some  environment  variables;  for  example,  if  the  program  name  is
'/usr/local/bin/python'
, the prefix is 
'/usr/local'
. The returned string points into
static storage; the caller should not modify its value. This corresponds to the prefix
variable in the top-level 
Makefile
and the 
--prefix
argument to the configure script
at build time. The value is available to Python code as 
sys.prefix
. It is only useful on
Unix. See also the next function.
Online Change your PDF file Permission Settings
easy as possible to change your PDF file permission settings. You can receive the locked PDF by simply clicking download and you are good to go!. Web Security.
pdf security settings; change pdf document security
VB.NET PDF Password Library: add, remove, edit PDF file password
RasterEdge XDoc.PDF SDK provides some PDF security settings about password to help protect your PDF document Add password to PDF. Change PDF original password.
decrypt a pdf; decrypt pdf
char* 
Py_GetExecPrefix
()
Return the exec-prefix for installed platform-dependent files. This is derived through a
number of complicated rules from the program name set with 
Py_SetProgramName()
and  some  environment  variables;  for  example,  if  the  program  name  is
'/usr/local/bin/python'
, the exec-prefix is 
'/usr/local'
. The returned string points
into static storage; the caller should not modify its value. This corresponds to the
exec_prefix variable in the top-level 
Makefile
and the 
--exec-prefix
argument to
the configure  script  at  build time. The  value  is  available  to  Python  code  as
sys.exec_prefix
. It is only useful on Unix.
Background: The exec-prefix differs from the prefix when platform dependent files
(such as executables and shared libraries) are installed in a different directory tree. In
a typical installation, platform dependent files may be installed in the 
/usr/local/plat
subtree while platform independent may be installed in 
/usr/local
.
Generally speaking, a platform is a combination of hardware and software families,
e.g. Sparc machines running the Solaris 2.x operating system are considered the
same platform, but Intel machines running Solaris 2.x are another platform, and Intel
machines running Linux are yet another platform. Different major revisions of the
same operating system generally also form different platforms. Non-Unix operating
systems are a different story; the installation strategies on those systems are so
different that the prefix and exec-prefix are meaningless, and set to the empty string.
Note  that  compiled  Python  bytecode  files  are  platform  independent  (but  not
independent from the Python version by which they were compiled!).
System administrators will know how to configure the mount or automount programs
to share 
/usr/local
between platforms while having 
/usr/local/plat
be a different
filesystem for each platform.
char* 
Py_GetProgramFullPath
()
Return the full program name of the Python executable; this is computed as a side-
effect of deriving the default module search path from the program name (set by
Py_SetProgramName()
above). The returned string points into static storage; the caller
should not modify its value. The value is available to Python code as 
sys.executable
.
char* 
Py_GetPath
()
Return the default module search path; this is computed from the program name (set
by 
Py_SetProgramName()
above) and some environment variables. The returned string
consists of a series of directory names separated by a platform dependent delimiter
character. The delimiter character is 
':'
on Unix and Mac OS X, 
';'
on Windows.
The returned string points into static storage; the caller should not modify its value.
C# PDF Password Library: add, remove, edit PDF file password in C#
Able to change password on adobe PDF document in C#.NET. To help protect your PDF document in C# project, XDoc.PDF provides some PDF security settings.
pdf file security; create encrypted pdf
Online Split PDF file. Best free online split PDF tool.
You can use our .NET PDF SDK to set file split settings for your PDF You can receive the PDF files by simply clicking download and you are good to Web Security.
creating secure pdf files; convert locked pdf to word online
The  list 
sys.path
is initialized with this value on interpreter startup; it can be (and
usually is) modified later to change the search path for loading modules.
const char* 
Py_GetVersion
()
Return the version of this Python interpreter. This is a string that looks something like
"1.5 (#67, Dec 31 1997, 22:34:28) [GCC 2.7.2.2]"
The first word (up to the first space character) is the current Python version; the first
three characters are the major and minor version separated by a period. The returned
string points into static storage; the caller should not modify its value. The value is
available to Python code as 
sys.version
.
const char* 
Py_GetPlatform
()
Return the platform identifier for the current platform. On Unix, this is formed from the
“official” name of the operating system, converted to lower case, followed by the
major revision number; e.g., for Solaris 2.x, which is also known as SunOS 5.x, the
value  is 
'sunos5'
. On  Mac  OS X, it is 
'darwin'
. On  Windows,  it  is 
'win'
. The
returned string points into static storage; the caller should not modify its value. The
value is available to Python code as 
sys.platform
.
const char* 
Py_GetCopyright
()
Return the official copyright string for the current Python version, for example
'Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam'
The returned string points into static storage; the caller should not modify its value.
The value is available to Python code as 
sys.copyright
.
const char* 
Py_GetCompiler
()
Return an indication of the compiler used to build the current Python version, in
square brackets, for example:
"[GCC 2.7.2.2]"
The returned string points into static storage; the caller should not modify its value.
The value is available to Python code as part of the variable 
sys.version
.
const char* 
Py_GetBuildInfo
()
Return information about the sequence number and build date and time of the current
Python interpreter instance, for example
Online Remove password from protected PDF file
If we need a password from you, it will not be read or stored. To hlep protect your PDF document in C# project, XDoc.PDF provides some PDF security settings.
creating a secure pdf document; copy 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
pdf security password; pdf secure
"#67, Aug  1 1997, 22:34:28"
The returned string points into static storage; the caller should not modify its value.
The value is available to Python code as part of the variable 
sys.version
.
void 
PySys_SetArgvEx
(
int argc, char **argv, int updatepath
)
Set 
sys.argv
based on argc and argv. These parameters are similar to those passed
to the program’s 
main()
function with the difference that the first entry should refer to
the  script  file  to  be  executed  rather  than  the  executable  hosting  the  Python
interpreter. If there isn’t a script that will be run, the first entry in argv can be an empty
string. If this function fails to initialize 
sys.argv
, a fatal condition is signalled using
Py_FatalError()
.
If updatepath is zero, this is all the function does. If updatepath is non-zero, the
function also modifies 
sys.path
according to the following algorithm:
If the name of an existing script is passed in 
argv[0]
, the absolute path of the
directory where the script is located is prepended to 
sys.path
.
Otherwise (that is, if argc is 0 or 
argv[0]
doesn’t point to an existing file name),
an empty string is prepended to 
sys.path
, which is the same as prepending the
current working directory (
"."
).
Note:  It is recommended that applications embedding the Python interpreter for
purposes other than executing a single script pass 0 as updatepath, and update
sys.path
themselves if desired. See CVE-2008-5983.
On versions before 2.6.6, you can achieve the same effect by manually popping the
first 
sys.path
element after having called 
PySys_SetArgv()
, for example using:
PyRun_SimpleString("import sys; sys.path.pop(0)\n");
New in version 2.6.6.
void 
PySys_SetArgv
(
int argc, char **argv
)
This function works like 
PySys_SetArgvEx()
with updatepath set to 1.
void 
Py_SetPythonHome
(
char *home
)
Set the default “home” directory, that is, the location of the standard Python libraries.
See 
PYTHONHOME
for the meaning of the argument string.
The argument should point to a zero-terminated character string in static storage
whose contents will not change for the duration of the program’s execution. No code
C# HTML5 Viewer: Deployment on AzureCloudService
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
create pdf security; secure pdf remove
C# HTML5 Viewer: Deployment on ASP.NET MVC
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
decrypt pdf password online; pdf security
in the Python interpreter will change the contents of this storage.
char* 
Py_GetPythonHome
()
Return  the  default  “home”,  that  is,  the  value  set  by  a  previous  call  to
Py_SetPythonHome()
, or the value of the 
PYTHONHOME
environment variable if it is set.
Thread State and the Global Interpreter Lock
The Python interpreter is not fully thread-safe. In order to support multi-threaded Python
programs, there’s a global lock, called the global interpreter lock  or GIL, that must be
held by the current thread before it can safely access Python objects. Without the lock,
even the simplest operations could cause problems in a multi-threaded program: for
example, when two threads simultaneously increment the reference count of the same
object, the reference count could end up being incremented only once instead of twice.
Therefore, the rule exists that only the thread that has acquired the GIL may operate on
Python  objects or call  Python/C API  functions.  In  order  to  emulate  concurrency  of
execution, the interpreter regularly tries to switch threads (see 
sys.setcheckinterval()
).
The lock is also released around potentially blocking I/O operations like reading or writing
a file, so that other Python threads can run in the meantime.
The Python interpreter keeps some thread-specific bookkeeping information inside a data
structure called 
PyThreadState
. There’s also one global variable pointing to the current
PyThreadState
: it can be retrieved using 
PyThreadState_Get()
.
Releasing the GIL from extension code
Most extension code manipulating the GIL has the following simple structure:
Save the thread state in a local variable.
Release the global interpreter lock.
... Do some blocking I/O operation ...
Reacquire the global interpreter lock.
Restore the thread state from the local variable.
This is so common that a pair of macros exists to simplify it:
Py_BEGIN_ALLOW_THREADS
... Do some blocking I/O operation ...
Py_END_ALLOW_THREADS
The 
Py_BEGIN_ALLOW_THREADS
macro opens a new block and declares a hidden local
variable; the 
Py_END_ALLOW_THREADS
macro closes the block. These two macros are still
Online Convert Jpeg to PDF file. Best free online export Jpg image
the conversion settings you like, and download it with one click. The entire process is quick, free and very easy. Web Security. All your JPG and PDF files will
change pdf document security; decrypt pdf online
available when Python is compiled without thread support (they simply have an empty
expansion).
When thread support is enabled, the block above expands to the following code:
PyThreadState *_save;
_save = PyEval_SaveThread();
...Do some blocking I/O operation...
PyEval_RestoreThread(_save);
Here is how these functions work: the global interpreter lock is used to protect the pointer
to the current thread state. When releasing the lock and saving the thread state, the
current thread state pointer must be retrieved before the lock is released (since another
thread could immediately acquire the lock and store its own thread state in the global
variable). Conversely, when acquiring the lock and restoring the thread state, the lock
must be acquired before storing the thread state pointer.
Note:  Calling system I/O functions is the most common use case for releasing the
GIL, but it can also be useful before calling long-running computations which don’t need
access to Python objects, such as compression or cryptographic functions operating
over memory buffers. For example, the standard 
zlib
and 
hashlib
modules release
the GIL when compressing or hashing data.
Non-Python created threads
When threads are created using the dedicated Python APIs (such as the 
threading
module), a thread state is automatically associated to them and the code showed above
is therefore correct. However, when threads are created from C (for example by a third-
party library with its own thread management), they don’t hold the GIL, nor is there a
thread state structure for them.
If you need to call Python code from these threads (often this will be part of a callback
API provided by the aforementioned third-party library), you must first register these
threads with the interpreter by creating a thread state data structure, then acquiring the
GIL, and finally storing their thread state pointer, before you can start using the Python/C
API. When you are done, you should reset the thread state pointer, release the GIL, and
finally free the thread state data structure.
The 
PyGILState_Ensure()
and 
PyGILState_Release()
functions  do  all  of  the  above
automatically. The typical idiom for calling into Python from a C thread is:
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
/* Perform Python actions here. */
result = CallSomeFunction();
/* evaluate result or handle exception */
/* Release the thread. No Python API allowed beyond this point. */
PyGILState_Release(gstate);
Note  that  the 
PyGILState_*()
functions assume there  is only one global interpreter
(created automatically by 
Py_Initialize()
). Python supports the creation of additional
interpreters  (using 
Py_NewInterpreter()
),  but  mixing  multiple  interpreters  and  the
PyGILState_*()
API is unsupported.
Another important thing to note about threads is their behaviour in the face of the C
fork()
call. On most systems with 
fork()
, after a process forks only the thread that
issued the fork will exist. That also means any locks held by other threads will never be
released. Python solves this for 
os.fork()
by acquiring the locks it uses internally before
the fork, and releasing them afterwards. In addition, it resets any Lock Objects in the
child.  When extending  or  embedding  Python,  there  is  no  way  to  inform  Python  of
additional (non-Python) locks that need to be acquired before or reset after a fork. OS
facilities such as 
pthread_atfork()
would need to be used to accomplish the same thing.
Additionally, when extending or embedding Python, calling 
fork()
directly rather than
through 
os.fork()
(and returning to or calling into Python) may result in a deadlock by
one of Python’s internal locks being held by a thread that is defunct after the fork.
PyOS_AfterFork()
tries to reset the necessary locks, but is not always able to.
High-level API
These are the most commonly used types and functions when writing C extension code,
or when embedding the Python interpreter:
PyInterpreterState
This data structure represents the state shared by a number of cooperating threads.
Threads belonging to the same interpreter share their module administration and a
few other internal items. There are no public members in this structure.
Threads belonging to different interpreters initially share nothing, except process state
like available memory, open file descriptors and such. The global interpreter lock is
also shared by all threads, regardless of to which interpreter they belong.
PyThreadState
This data structure represents the state of a single thread. The only public data
member  is 
PyInterpreterState *interp
, which points to this thread’s interpreter
state.
void 
PyEval_InitThreads
()
Initialize and acquire the global interpreter lock. It should be called in the main thread
before creating a second thread or engaging in any other thread operations such as
PyEval_ReleaseLock()
or 
PyEval_ReleaseThread(tstate)
. It is not needed before
calling 
PyEval_SaveThread()
or 
PyEval_RestoreThread()
.
This is a no-op when called for a second time. It is safe to call this function before
calling 
Py_Initialize()
.
Note:  When only the main thread exists, no GIL operations are needed. This is a
common  situation  (most  Python  programs  do  not  use  threads),  and  the  lock
operations slow the interpreter down a bit. Therefore, the lock is not created initially.
This situation is equivalent to having acquired the lock: when there is only a single
thread, all object accesses are safe. Therefore, when this function initializes the
global interpreter lock, it also acquires it. Before the Python 
_thread
module creates
a new thread, knowing that either it has the lock or the lock hasn’t been created yet,
it calls 
PyEval_InitThreads()
. When this call returns, it is guaranteed that the lock
has been created and that the calling thread has acquired it.
It is not safe to call this function when it is unknown which thread (if any) currently
has the global interpreter lock.
This function is not available when thread support is disabled at compile time.
int 
PyEval_ThreadsInitialized
()
Returns a non-zero value if 
PyEval_InitThreads()
has been called. This function can
be called without holding the GIL, and therefore can be used to avoid calls to the
locking API when running single-threaded. This function is not available when thread
support is disabled at compile time.
New in version 2.4.
PyThreadState
PyEval_SaveThread
()
Release the global interpreter lock (if it has been created and thread support is
enabled) and reset the thread state to NULL, returning the previous thread state
(which  is  not NULL). If the lock has been created, the current thread must have
acquired it. (This function is available even when thread support is disabled at compile
time.)
void 
PyEval_RestoreThread
(
PyThreadState *tstate
)
Acquire the global interpreter lock (if it has  been created and thread support is
enabled) and set the thread state to tstate, which must not be NULL. If the lock has
been created,  the current  thread  must not  have acquired  it, otherwise deadlock
ensues. (This function is available even when thread support is disabled at compile
time.)
PyThreadState
PyThreadState_Get
()
Return the current thread state. The global interpreter lock must be held. When the
current thread state is NULL, this issues a fatal error (so that the caller needn’t check
for NULL).
PyThreadState
PyThreadState_Swap
(
PyThreadState *tstate
)
Swap the current thread state with the thread state given by the argument tstate,
which may be NULL. The global interpreter lock must be held and is not released.
void 
PyEval_ReInitThreads
()
This  function  is  called  from 
PyOS_AfterFork()
to ensure that newly created child
processes don’t hold locks referring to threads which are not running in the child
process.
The following  functions  use  thread-local  storage,  and  are  not  compatible  with  sub-
interpreters:
PyGILState_STATE 
PyGILState_Ensure
()
Ensure that the current thread is ready to call the Python C API regardless of the
current state of Python, or of the global interpreter lock. This may be called as many
times  as  desired  by  a  thread  as  long  as  each  call  is  matched  with  a  call  to
PyGILState_Release()
. In general, other thread-related APIs may be used between
PyGILState_Ensure()
and 
PyGILState_Release()
calls as long as the thread state is
restored to its previous state before the Release(). For example, normal usage of the
Py_BEGIN_ALLOW_THREADS
and 
Py_END_ALLOW_THREADS
macros is acceptable.
The return value is an opaque “handle” to the thread state when 
PyGILState_Ensure()
was called, and must be passed to 
PyGILState_Release()
to ensure Python is left in
the same state. Even though recursive calls are allowed, these handles cannot be
shared - each unique call to 
PyGILState_Ensure()
must save the handle for its call to
PyGILState_Release()
.
When the function returns, the current thread will hold the GIL and be able to call
arbitrary Python code. Failure is a fatal error.
New in version 2.3.
Documents you may be interested
Documents you may be interested