how to convert pdf to image using itextsharp in c# : Change pdf security settings reader application Library tool html .net windows online Official%20Python%20Manual%20of%20Python%202.7.6%20288-part1723

S
(string) [PyStringObject *]
Like 
O
but requires that the Python object is a string object. Raises 
TypeError
if the
object is not a string object. The C variable may also be declared as 
PyObject*
.
U
(Unicode string) [PyUnicodeObject *]
Like 
O
but requires that the Python object is a Unicode object. Raises 
TypeError
if the
object is not a Unicode object. The C variable may also be declared as 
PyObject*
.
t#
(read-only character buffer) [char *, int]
Like 
s#
, but accepts any object which implements the read-only buffer interface. The
char*
variable is set to point to the first byte of the buffer, and the 
int
is set to the
length of the buffer. Only single-segment buffer objects are accepted; 
TypeError
is
raised for all others.
w
(read-write character buffer) [char *]
Similar to 
s
, but accepts any object which implements the read-write buffer interface.
The caller must determine the length of the buffer by other means, or use 
w#
instead.
Only single-segment buffer objects are accepted; 
TypeError
is raised for all others.
w#
(read-write character buffer) [char *, Py_ssize_t]
Like 
s#
, but accepts any object which implements the read-write buffer interface. The
char *
variable is set to point to the first byte of the buffer, and the 
Py_ssize_t
is set
to  the  length  of  the  buffer. Only  single-segment  buffer  objects  are  accepted;
TypeError
is raised for all others.
w*
(read-write byte-oriented buffer) [Py_buffer]
This is to 
w
what 
s*
is to 
s
.
New in version 2.6.
(items)
(tuple) [matching-items]
The object must be a Python sequence whose length is the number of format units in
items. The C arguments must correspond to the individual format units in items.
Format units for sequences may be nested.
Note:  Prior to Python version 1.5.2, this format specifier only accepted a tuple
containing  the  individual  parameters,  not  an  arbitrary  sequence.  Code  which
previously  caused 
TypeError
to  be raised here may now proceed without an
exception. This is not expected to be a problem for existing code.
It is possible to pass Python long integers where integers are requested; however no
proper range checking is done — the most significant bits are silently truncated when the
receiving field is too small to receive the value (actually, the semantics are inherited from
Change pdf security settings reader - 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
decrypt pdf; pdf password encryption
Change pdf security settings reader - 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
copy text from locked pdf; create pdf the security level is set to high
downcasts in C — your mileage may vary).
A few other characters have a meaning in a format string. These may not occur inside
nested parentheses. They are:
|
Indicates that the remaining arguments in the Python argument list are optional. The
C variables corresponding to optional arguments should be initialized to their default
value — when an optional argument is not specified, 
PyArg_ParseTuple()
does not
touch the contents of the corresponding C variable(s).
:
The list of format units ends here; the string after the colon is used as the function
name  in  error  messages  (the  “associated  value”  of  the  exception  that
PyArg_ParseTuple()
raises).
;
The list of format units ends here; the string after the semicolon is used as the error
message instead of the default error message. 
:
and 
;
mutually exclude each other.
Note that any Python object references which are provided to the caller are borrowed
references; do not decrement their reference count!
Additional arguments passed to these functions must be addresses of variables whose
type is determined by the format string; these are used to store values from the input
tuple. There are a few cases, as described in the list of format units above, where these
parameters are used as input values; they should match what is specified for the
corresponding format unit in that case.
For the conversion to succeed, the arg object must match the format and the format
must be exhausted. On success, the 
PyArg_Parse*()
functions return true, otherwise
they return false and raise an appropriate exception. When the 
PyArg_Parse*()
functions
fail due to conversion failure in one of the format units, the variables at the addresses
corresponding to that and the following format units are left untouched.
int 
PyArg_ParseTuple
(
PyObject *args, const char *format, ...
)
Parse the parameters of a function that takes only positional parameters into local
variables. Returns  true  on  success;  on  failure,  it  returns  false  and  raises  the
appropriate exception.
int 
PyArg_VaParse
(
PyObject *args, const char *format, va_list vargs
)
Identical to 
PyArg_ParseTuple()
, except that it accepts a va_list rather than a variable
number of arguments.
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 pdf password; pdf password unlock
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.
convert locked pdf to word; pdf secure
int 
PyArg_ParseTupleAndKeywords
(
PyObject *args, PyObject *kw, const char *format,
char *keywords[], ...
)
Parse the parameters of a function that takes both positional and keyword parameters
into local variables. Returns true on success; on failure, it returns false and raises the
appropriate exception.
int 
PyArg_VaParseTupleAndKeywords
(
PyObject *args, PyObject *kw, const
char *format, char *keywords[], va_list vargs
)
Identical to 
PyArg_ParseTupleAndKeywords()
, except that it accepts a va_list rather
than a variable number of arguments.
int 
PyArg_Parse
(
PyObject *args, const char *format, ...
)
Function used to deconstruct the argument lists of “old-style” functions — these are
functions  which  use  the 
METH_OLDARGS
parameter  parsing  method. This  is  not
recommended for use in parameter parsing in new code, and most code in the
standard interpreter has been modified to no longer use this for that purpose. It does
remain a convenient way to decompose other tuples, however, and may continue to
be used for that purpose.
int 
PyArg_UnpackTuple
(
PyObject *args, const char *name, Py_ssize_t min,
Py_ssize_t max, ...
)
A simpler form of parameter retrieval which does not use a format string to specify the
types of the arguments. Functions which use this method to retrieve their parameters
should  be  declared  as 
METH_VARARGS
in  function  or  method  tables. The  tuple
containing the actual parameters should be passed as args; it must actually be a
tuple. The length of the tuple must be at least min and no more than max; min and
max may be equal. Additional arguments must be passed to the function, each of
which should be a pointer to a 
PyObject*
variable; these will be filled in with the values
from args; they will contain borrowed references. The variables which correspond to
optional parameters not given by args will not be filled in; these should be initialized by
the caller. This function returns true on success and false if args is not a tuple or
contains the wrong number of elements; an exception will be set if there was a failure.
This is an example of the use of this function, taken from the sources for the
_weakref
helper module for weak references:
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
creating secure pdf files; pdf unlock
C# HTML5 Viewer: Deployment on AzureCloudService
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
change pdf document security; pdf security
static PyObject *
weakref_ref(PyObject *self, PyObject *args)
{
PyObject *object;
PyObject *callback = NULL;
PyObject *result = NULL;
if (PyArg_UnpackTuple(args, "ref"12&object, &callback)) {
result = PyWeakref_NewRef(object, callback);
}
return result;
}
The call to 
PyArg_UnpackTuple()
in this example is entirely equivalent to this call to
PyArg_ParseTuple()
:
PyArg_ParseTuple(args, "O|O:ref", &object, &callback)
New in version 2.2.
Changed in version 2.5: This function used an 
int
type for min and max. This might
require changes in your code for properly supporting 64-bit systems.
PyObject
Py_BuildValue
(
const char *format, ...
)
Return value: New reference.
Create a new value based on a format string similar to those accepted by the
PyArg_Parse*()
family of functions and a sequence of values. Returns the value or
NULL in the case of an error; an exception will be raised if NULL is returned.
Py_BuildValue()
does not always build a tuple. It builds a tuple only if its format string
contains two or more format units. If the format string is empty, it returns 
None
; if it
contains exactly one format unit, it returns whatever object is described by that format
unit. To force it to return a tuple of size 0 or one, parenthesize the format string.
When memory buffers are passed as parameters to supply data to build objects, as
for the 
s
and 
s#
formats, the required data is copied. Buffers provided by the caller
are never referenced by the objects created by 
Py_BuildValue()
. In other words, if
your code invokes 
malloc()
and passes the allocated memory to 
Py_BuildValue()
,
your code is responsible for calling 
free()
for that memory once 
Py_BuildValue()
returns.
In the following description, the quoted form is the format unit; the entry in (round)
parentheses is the Python object type that the format unit will return; and the entry in
[square] brackets is the type of the C value(s) to be passed.
The characters space, tab, colon and comma are ignored in format strings (but not
C# HTML5 Viewer: Deployment on ASP.NET MVC
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
pdf password security; decrypt pdf file online
C# Imaging - Decode Code 93 Barcode in C#.NET
the purpose to provide a higher density and data security enhancement to Load an image or a document(PDF, TIFF, Word, Excel Set the barcode reader settings.
convert locked pdf to word doc; add security to pdf file
within format units such as 
s#
). This can be used to make long format strings a tad
more readable.
s
(string) [char *]
Convert a null-terminated C string to a Python object. If the C string pointer is
NULL, 
None
is used.
s#
(string) [char *, int]
Convert a C string and its length to a Python object. If the C string pointer is NULL,
the length is ignored and 
None
is returned.
z
(string or 
None
) [char *]
Same as 
s
.
z#
(string or 
None
) [char *, int]
Same as 
s#
.
u
(Unicode string) [Py_UNICODE *]
Convert a null-terminated buffer of Unicode (UCS-2 or UCS-4) data to a Python
Unicode object. If the Unicode buffer pointer is NULL, 
None
is returned.
u#
(Unicode string) [Py_UNICODE *, int]
Convert a Unicode (UCS-2 or UCS-4) data buffer and its length to a Python
Unicode object. If the Unicode buffer pointer is NULL, the length is ignored and
None
is returned.
i
(integer) [int]
Convert a plain C 
int
to a Python integer object.
b
(integer) [char]
Convert a plain C 
char
to a Python integer object.
h
(integer) [short int]
Convert a plain C 
short int
to a Python integer object.
l
(integer) [long int]
Convert a C 
long int
to a Python integer object.
B
(integer) [unsigned char]
Convert a C 
unsigned char
to a Python integer object.
H
(integer) [unsigned short int]
Convert a C 
unsigned short int
to a Python integer object.
I
(integer/long) [unsigned int]
C# Image: C# Code to Upload TIFF File to Remote Database by Using
Website project and select WSE Settings 3.0. using System.Security.Cryptography; private void tsbUpload_Click & profession imaging controls, PDF document, image
convert secure webpage to pdf; decrypt password protected pdf
VB Imaging - VB Codabar Generator
check digit function for user's security consideration. also creates Codabar bar code on PDF, WORD, TIFF Able to adjust parameter settings before encoding, like
cannot print pdf security; change security settings pdf reader
Convert a C 
unsigned int
to a Python integer object or a Python long integer
object, if it is larger than 
sys.maxint
.
k
(integer/long) [unsigned long]
Convert a C 
unsigned long
to a Python integer object or a Python long integer
object, if it is larger than 
sys.maxint
.
L
(long) [PY_LONG_LONG]
Convert a C 
long long
to a Python long integer object. Only available on platforms
that support 
long long
.
K
(long) [unsigned PY_LONG_LONG]
Convert a C 
unsigned long long
to a Python long integer object. Only available on
platforms that support 
unsigned long long
.
n
(int) [Py_ssize_t]
Convert a C 
Py_ssize_t
to a Python integer or long integer.
New in version 2.5.
c
(string of length 1) [char]
Convert a C 
int
representing a character to a Python string of length 1.
d
(float) [double]
Convert a C 
double
to a Python floating point number.
f
(float) [float]
Same as 
d
.
D
(complex) [Py_complex *]
Convert a C 
Py_complex
structure to a Python complex number.
O
(object) [PyObject *]
Pass  a  Python  object  untouched  (except  for  its  reference  count,  which  is
incremented by one). If the object passed in is a NULL pointer, it is assumed that
this was caused because the call producing the argument found an error and set
an  exception.  Therefore, 
Py_BuildValue()
will  return NULL but won’t raise an
exception. If no exception has been raised yet, 
SystemError
is set.
S
(object) [PyObject *]
Same as 
O
.
N
(object) [PyObject *]
Same as 
O
, except it doesn’t increment the reference count on the object. Useful
when the object is created by a call to an object constructor in the argument list.
O&
(object) [converter, anything]
Convert anything to a Python object through a converter function. The function is
called with anything (which should be compatible with 
void *
) as its argument and
should return a “new” Python object, or NULL if an error occurred.
(items)
(tuple) [matching-items]
Convert a sequence of C values to a Python tuple with the same number of items.
[items]
(list) [matching-items]
Convert a sequence of C values to a Python list with the same number of items.
{items}
(dictionary) [matching-items]
Convert a sequence of C values to a Python dictionary. Each pair of consecutive C
values adds one item to the dictionary, serving as key and value, respectively.
If there is an error in the format string, the 
SystemError
exception is set and NULL
returned.
PyObject
Py_VaBuildValue
(
const char *format, va_list vargs
)
Identical to 
Py_BuildValue()
, except that it accepts a va_list rather than a variable
number of arguments.
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » Python/C API Reference Manual » Utilities »
© Copyright
1990-2013, Python Software Foundation. 
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Nov 10, 2013. Found a bug
Created using Sphinx
1.0.7.
index
modules |
next |
previous |
String conversion and formatting
Functions for number conversion and formatted string output.
int 
PyOS_snprintf
(
char *str, size_t size, const char *format, ...
)
Output not more than size bytes to str according to the format string format and the
extra arguments. See the Unix man page snprintf(2).
int 
PyOS_vsnprintf
(
char *str, size_t size, const char *format, va_list va
)
Output not more than size bytes to str according to the format string format and the
variable argument list va. Unix man page vsnprintf(2).
PyOS_snprintf()
and 
PyOS_vsnprintf()
wrap  the  Standard  C  library  functions
snprintf()
and 
vsnprintf()
. Their purpose is to guarantee consistent behavior in corner
cases, which the Standard C functions do not.
The wrappers ensure that str*[*size-1] is always 
'\0'
upon return. They never write more
than size bytes (including the trailing 
'\0'
into str. Both functions require that 
str !=
NULL
size > 0
and 
format != NULL
.
If the platform doesn’t have 
vsnprintf()
and the buffer size needed to avoid truncation
exceeds size by more than 512 bytes, Python aborts with a Py_FatalError.
The return value (rv) for these functions should be interpreted as follows:
When 
0 <= rv < size
, the output conversion was successful and rv characters were
written to str (excluding the trailing 
'\0'
byte at str*[*rv]).
When 
rv >= size
, the output conversion was truncated and a buffer with 
rv + 1
bytes would have been needed to succeed. str*[*size-1] is 
'\0'
in this case.
When 
rv < 0
, “something bad happened.” str*[*size-1] is 
'\0'
in this case too, but
the rest of str is undefined. The exact cause of the error depends on the underlying
platform.
The following functions provide locale-independent string to number conversions.
double 
PyOS_string_to_double
(
const char *s, char **endptr,
PyObject *overflow_exception
)
Convert a string 
s
to a 
double
, raising a Python exception on failure. The set of
accepted strings corresponds to the set of strings accepted by Python’s 
float()
Python » Python v2.7.6 documentation » Python/C API Reference Manual » Utilities »
constructor,  except  that 
s
must  not  have  leading  or  trailing  whitespace.  The
conversion is independent of the current locale.
If 
endptr
is 
NULL
, convert the whole string. Raise ValueError and return 
-1.0
if the
string is not a valid representation of a floating-point number.
If endptr is not 
NULL
, convert as much of the string as possible and set 
*endptr
to
point to the first unconverted character. If no initial segment of the string is the valid
representation of a floating-point number, set 
*endptr
to point to the beginning of the
string, raise ValueError, and return 
-1.0
.
If 
s
represents a value that is too large to store in a float (for example, 
"1e500"
is
such  a  string  on  many  platforms)  then  if 
overflow_exception
is 
NULL
return
Py_HUGE_VAL
(with  an appropriate  sign)  and don’t  set  any  exception. Otherwise,
overflow_exception
must point to a Python exception object; raise that exception and
return 
-1.0
. In  both  cases,  set 
*endptr
to point to the first character after the
converted value.
If any other error occurs during the conversion (for example an out-of-memory error),
set the appropriate Python exception and return 
-1.0
.
New in version 2.7.
double 
PyOS_ascii_strtod
(
const char *nptr, char **endptr
)
Convert a string to a 
double
. This function behaves like the Standard C function
strtod()
does in the C locale. It does this without changing the current locale, since
that would not be thread-safe.
PyOS_ascii_strtod()
should typically be used for reading configuration files or other
non-user input that should be locale independent.
See the Unix man page strtod(2) for details.
New in version 2.4.
Deprecated since version 2.7: Use 
PyOS_string_to_double()
instead.
char* 
PyOS_ascii_formatd
(
char *buffer, size_t buf_len, const char *format, double d
)
Convert a 
double
to a string using the 
'.'
as the decimal separator. format is a
printf()
-style  format  string  specifying  the  number  format.  Allowed  conversion
characters are 
'e'
'E'
'f'
'F'
'g'
and 
'G'
.
The return value is a pointer to buffer with the converted string or NULL if the
conversion failed.
New in version 2.4.
Deprecated since version 2.7: This function is removed in Python 2.7 and 3.1. Use
PyOS_double_to_string()
instead.
char* 
PyOS_double_to_string
(
double val, char format_code, int precision, int flags,
int *ptype
)
Convert a 
double
val to a string using supplied format_code, precision, and flags.
format_code must be one of 
'e'
'E'
'f'
'F'
'g'
'G'
or 
'r'
. For 
'r'
, the
supplied precision must be 0 and is ignored. The 
'r'
format code specifies the
standard 
repr()
format.
flags can be zero or more of the values Py_DTSF_SIGN, Py_DTSF_ADD_DOT_0, or
Py_DTSF_ALT, or-ed together:
Py_DTSF_SIGN  means  to  always  precede  the  returned  string  with  a  sign
character, even if val is non-negative.
Py_DTSF_ADD_DOT_0 means to ensure that the returned string will not look like
an integer.
Py_DTSF_ALT  means  to  apply  “alternate”  formatting  rules. See  the
documentation for the 
PyOS_snprintf()
'#'
specifier for details.
I f ptype  is  non-NULL,  then  the  value  it  points  to  will  be  set  to  one  of
Py_DTST_FINITE, Py_DTST_INFINITE,  or Py_DTST_NAN,  signifying  that val is a
finite number, an infinite number, or not a number, respectively.
The return value is a pointer to buffer with the converted string  or NULL if the
conversion failed. The caller is responsible for freeing the returned string by calling
PyMem_Free()
.
New in version 2.7.
double 
PyOS_ascii_atof
(
const char *nptr
)
Convert a string to a 
double
in a locale-independent way.
See the Unix man page atof(2) for details.
New in version 2.4.
Documents you may be interested
Documents you may be interested