c# convert pdf to tiff : Adding signature to pdf file Library control class asp.net web page azure ajax pcb338-part430

To support such keyword arguments in a metaclass, make sure you define them on the
__prepare__()__new__(), and __init__() methods using keyword-only arguments,
like this:
class MyMeta(type):
# Optional
@classmethod
def __prepare__(cls, namebases, *debug=Falsesynchronize=False):
# Custom processing
...
return super().__prepare__(namebases)
# Required
def __new__(clsnamebases, ns, *debug=Falsesynchronize=False):
# Custom processing
...
return super().__new__(clsnamebases, ns)
# Required
def __init__(selfnamebasesns, *debug=False, synchronize=False):
# Custom processing
...
super().__init__(namebases, ns)
Discussion
Adding optional keyword arguments to a metaclass requires that you understand all of
the steps involved in class creation, because the extra arguments are passed to every
method involved. The __prepare__() method is called first and used to create the class
namespace prior to the body of any class definition being processed. Normally, this
method simply returns a dictionary or other mapping object. The __new__() method
is used to instantiate the resulting type object. It is called after the class body has been
fully executed. The __init__() method is called last and used to perform any additional
initialization steps.
When writing metaclasses, it is somewhat common to only define a __new__()  or
__init__() method, but not both. However, if extra keyword arguments are going to
be accepted, then both methods must be provided and given compatible signatures. The
default __prepare__() method accepts any set of keyword arguments, but ignores them.
You only need to define it yourself if the extra arguments would somehow affect man‐
agement of the class namespace creation.
The use of keyword-only arguments in this recipe reflects the fact that such arguments
will only be supplied by keyword during class creation.
The specification of keyword arguments to configure a metaclass might be viewed as
an alternative to using class variables for a similar purpose. For example:
9.15. Defining a Metaclass That Takes Optional Arguments  |  363
Adding signature to pdf file - C# PDF File Permission Library: add, remove, update PDF file permission in C#.net, ASP.NET, MVC, WPF
Tell C# users how to set PDF file permissions, like printing, copying, modifying, extracting, annotating, form filling, etc
pdf create signature; create signature pdf
Adding signature to pdf file - VB.NET PDF File Permission Library: add, remove, update PDF file permission in vb.net, ASP.NET, MVC, WPF
VB.NET Tutorial for How to Set PDF File Access Permissions Using XDoc.PDF for .NET
adding signature to pdf files; add signature pdf preview
class Spam(metaclass=MyMeta):
debug = True
synchronize = True
...
The advantage to supplying such parameters as an argument is that they don’t pollute
the class namespace with extra names that only pertain to class creation and not the
subsequent execution of statements in the class. In addition, they are available to the
__prepare__() method, which runs prior to processing any statements in the class body.
Class variables, on the other hand, would only be accessible in the __new__() and
__init__() methods of a metaclass.
9.16. Enforcing an Argument Signature on *args and
**kwargs
Problem
You’ve written a function or method that uses *args and **kwargs, so that it can be
general purpose, but you would also like to check the passed arguments to see if they
match a specific function calling signature.
Solution
For any problem where you want to manipulate function calling signatures, you should
use the signature features found in the inspect module. Two classes, Signature and
Parameter, are of particular interest here. Here is an interactive example of creating a
function signature:
>>> from inspect import SignatureParameter
>>> # Make a signature for a func(x, y=42, *, z=None)
>>> parms = [ Parameter('x'Parameter.POSITIONAL_OR_KEYWORD),
...           Parameter('y'Parameter.POSITIONAL_OR_KEYWORDdefault=42),
...           Parameter('z'Parameter.KEYWORD_ONLYdefault=None) ]
>>> sig = Signature(parms)
>>> print(sig)
(x, y=42, *, z=None)
>>>
Once you have a signature object, you can easily bind it to *args and **kwargs using
the signature’s bind() method, as shown in this simple example:
>>> def func(*args**kwargs):
...     bound_values = sig.bind(*args**kwargs)
...     for namevalue in bound_values.arguments.items():
...         print(name,value)
...
>>> # Try various examples
>>> func(12z=3)
364  |  Chapter 9: Metaprogramming
C# PDF Digital Signature Library: add, remove, update PDF digital
Help to Improve the Security of Your PDF File by Adding Digital Signatures. Overview. Add a signature or an empty signature field in any PDF file page.
add signature box to pdf; add signature to pdf preview
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Capable of adding PDF file navigation features to your VB.NET Password, digital signature and PDF text, image and page to a specific location on PDF file page.
pdf signature stamp; create pdf signature
x 1
y 2
z 3
>>> func(1)
x 1
>>> func(1z=3)
x 1
z 3
>>> func(y=2x=1)
x 1
y 2
>>> func(1234)
Traceback (most recent call last):
...
File "/usr/local/lib/python3.3/inspect.py", line 1972, in _bind
raise TypeError('too many positional arguments')
TypeErrortoo many positional arguments
>>> func(y=2)
Traceback (most recent call last):
...
File "/usr/local/lib/python3.3/inspect.py", line 1961, in _bind
raise TypeError(msgfrom None
TypeError'x' parameter lacking default value
>>> func(1y=2x=3)
Traceback (most recent call last):
...
File "/usr/local/lib/python3.3/inspect.py", line 1985, in _bind
'{arg!r}'.format(arg=param.name))
TypeErrormultiple values for argument 'x'
>>>
As you can see, the binding of a signature to the passed arguments enforces all of the
usual function calling rules concerning required arguments, defaults, duplicates, and
so forth.
Here is a more concrete example of enforcing function signatures. In this code, a base
class has defined an extremely general-purpose version of __init__(), but subclasses
are expected to supply an expected signature.
from inspect import SignatureParameter
def make_sig(*names):
parms = [Parameter(nameParameter.POSITIONAL_OR_KEYWORD)
for name in names]
return Signature(parms)
class Structure:
__signature__ = make_sig()
def __init__(self*args**kwargs):
bound_values = self.__signature__.bind(*args**kwargs)
for namevalue in bound_values.arguments.items():
setattr(selfnamevalue)
9.16. Enforcing an Argument Signature on *args and **kwargs  |  365
C# PDF insert image Library: insert images into PDF in C#.net, ASP
to insert and add image, picture, digital photo, scanned signature or logo this technical problem, we provide this C#.NET PDF image adding control, XDoc
pdf signatures; create pdf signature box
VB.NET PDF Digital Signature Library: add, remove, update PDF
VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures in Add a signature or an empty signature field in any PDF file page.
add signature image to pdf acrobat; pdf will signature
# Example use
class Stock(Structure):
__signature__ = make_sig('name', 'shares', 'price')
class Point(Structure):
__signature__ = make_sig('x', 'y')
Here is an example of how the Stock class works:
>>> import inspect
>>> print(inspect.signature(Stock))
(name, shares, price)
>>> s1 = Stock('ACME'100490.1)
>>> s2 = Stock('ACME'100)
Traceback (most recent call last):
...
TypeError'price' parameter lacking default value
>>> s3 = Stock('ACME'100490.1shares=50)
Traceback (most recent call last):
...
TypeErrormultiple values for argument 'shares'
>>>
Discussion
The use of functions involving *args and **kwargs is very common when trying to
make general-purpose libraries, write decorators or implement proxies. However, one
downside of such functions is that if you want to implement your own argument check‐
ing, it can quickly become an unwieldy mess. As an example, see Recipe 8.11. The use
of a signature object simplifies this.
In the last example of the solution, it might make sense to create signature objects
through the use of a custom metaclass. Here is an alternative implementation that shows
how to do this:
from inspect import SignatureParameter
def make_sig(*names):
parms = [Parameter(nameParameter.POSITIONAL_OR_KEYWORD)
for name in names]
return Signature(parms)
class StructureMeta(type):
def __new__(clsclsnamebases, clsdict):
clsdict['__signature__'= make_sig(*clsdict.get('_fields',[]))
return super().__new__(clsclsnamebases, clsdict)
class Structure(metaclass=StructureMeta):
_fields = []
def __init__(self*args**kwargs):
366  |  Chapter 9: Metaprogramming
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
C# .NET provides permanent annotations adding feature, all to PDF, including freehand signature, text and date signature. load and save it to current PDF file.
adding a signature to a pdf form; add signature pdf
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PowerPoint
users can convert PowerPoint to PDF (.pdf) online, convert and edited on PowerPoint file just by Users can perform text signature adding, freehand signature
add a signature to a pdf file; create transparent signature stamp for pdf
bound_values = self.__signature__.bind(*args**kwargs)
for namevalue in bound_values.arguments.items():
setattr(selfnamevalue)
# Example
class Stock(Structure):
_fields = ['name''shares''price']
class Point(Structure):
_fields = ['x''y']
When defining custom signatures, it is often useful to store the signature in a special
attribute __signature__, as shown. If you do this, code that uses the inspect module
to perform introspection will see the signature and report it as the calling convention.
For example:
>>> import inspect
>>> print(inspect.signature(Stock))
(name, shares, price)
>>> print(inspect.signature(Point))
(x, y)
>>>
9.17. Enforcing Coding Conventions in Classes
Problem
Your program consists of a large class hierarchy and you would like to enforce certain
kinds of coding conventions (or perform diagnostics) to help maintain programmer
sanity.
Solution
If you want  to monitor the definition of classes,  you can often do it by defining a
metaclass. A basic metaclass is usually defined by inheriting from type and redefining
its __new__() method or __init__() method. For example:
class MyMeta(type):
def __new__(self, clsnamebases, clsdict):
# clsname is name of class being defined
# bases is tuple of base classes
# clsdict is class dictionary
return super().__new__(clsclsnamebases, clsdict)
Alternatively, if __init__() is defined:
class MyMeta(type):
def __init__(selfclsnamebasesclsdict):
super().__init__(clsnamebases, clsdict)
# clsname is name of class being defined
9.17. Enforcing Coding Conventions in Classes  |  367
C# Create PDF Library SDK to convert PDF from other file formats
generated PDF file. What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF using C# code.
add signature field to pdf; export pdf sign in
.NET PDF SDK - Description of All PDF Processing Control Feastures
Add signature image to PDF file. PDF Hyperlink Edit. Support adding and inserting hyperlink (link) to PDF document; Allow to create, edit, and remove PDF bookmark
add signature pdf online; pdf export sign in
# bases is tuple of base classes
# clsdict is class dictionary
To use a metaclass, you would generally incorporate it into a top-level base class from
which other objects inherit. For example:
class Root(metaclass=MyMeta):
pass
class A(Root):
pass
class B(Root):
pass
A key feature of a metaclass is that it allows you to examine the contents of a class at the
time of definition. Inside the redefined __init__() method, you are free to inspect the
class dictionary, base classes, and more. Moreover, once a metaclass has been specified
for a class, it gets inherited by all of the subclasses. Thus, a sneaky framework builder
can specify a metaclass for one of the top-level classes in a large hierarchy and capture
the definition of all classes under it.
As a concrete albeit whimsical example, here is a metaclass that rejects any class defi‐
nition containing methods with mixed-case names (perhaps as a means for annoying
Java programmers):
class NoMixedCaseMeta(type):
def __new__(clsclsnamebases, clsdict):
for name in clsdict:
if name.lower() != name:
raise TypeError('Bad attribute name: ' + name)
return super().__new__(clsclsnamebases, clsdict)
class Root(metaclass=NoMixedCaseMeta):
pass
class A(Root):
def foo_bar(self):      # Ok
pass
class B(Root):
def fooBar(self):       # TypeError
pass
As a more advanced and useful example, here is a metaclass that checks the definition
of redefined methods to make sure they have the same calling signature as the original
method in the superclass.
from inspect import signature
import logging
class MatchSignaturesMeta(type):
368  |  Chapter 9: Metaprogramming
XDoc.HTML5 Viewer for .NET, All Mature Features Introductions
to search text-based documents, like PDF, Microsoft Office typing new signature, deleting added signature from the After adding such a control button, with a
copy and paste signature into pdf; add jpg signature to pdf
VB.NET TIFF: Add New Image to TIFF File in Visual Basic .NET
you want to copy an image, graphics, signature or logo the reliable and extensive TIFF page image adding tool that new image, stamp or any photo file to target
click to sign pdf; add signature block to pdf
def __init__(selfclsnamebasesclsdict):
super().__init__(clsnamebases, clsdict)
sup = super(selfself)
for namevalue in clsdict.items():
if name.startswith('_') or not callable(value):
continue
# Get the previous definition (if any) and compare the signatures
prev_dfn = getattr(sup,name,None)
if prev_dfn:
prev_sig = signature(prev_dfn)
val_sig = signature(value)
if prev_sig != val_sig:
logging.warning('Signature mismatch in %s%s != %s',
value.__qualname__prev_sig, val_sig)
# Example
class Root(metaclass=MatchSignaturesMeta):
pass
class A(Root):
def foo(selfxy):
pass
def spam(self, x*z):
pass
# Class with redefined methods, but slightly different signatures
class B(A):
def foo(selfab):
pass
def spam(self,x,z):
pass
If you run this code, you will get output such as the following:
WARNING:root:Signature mismatch in B.spam. (self, x, *, z) != (self, x, z)
WARNING:root:Signature mismatch in B.foo. (self, x, y) != (self, a, b)
Such warnings might be useful in catching subtle program bugs. For example, code that
relies on keyword argument passing to a method will break if a subclass changes the
argument names.
Discussion
In large object-oriented programs, it can sometimes be useful to put class definitions
under the control of a metaclass. The metaclass can observe class definitions and be
used to alert programmers to potential problems that might go unnoticed (e.g., using
slightly incompatible method signatures).
9.17. Enforcing Coding Conventions in Classes  |  369
One might argue that such errors would be better caught by program analysis tools or
IDEs. To be sure, such tools are useful. However, if you’re creating a framework or library
that’s going to be used by others, you often don’t have any control over the rigor of their
development practices. Thus, for certain kinds of applications, it might make sense to
put a bit of extra checking in a metaclass if such checking would result in a better user
experience.
The choice of redefining __new__() or __init__() in a metaclass depends on how you
want to work with the resulting class. __new__() is invoked prior to class creation and
is typically used when a metaclass wants to alter the class definition in some way (by
changing the contents of the class dictionary). The __init__() method is invoked after
a class has been created, and is useful if you want to write code that works with the fully
formed class object. In the last example, this is essential since it is using the super()
function to search for prior definitions. This only works once the class instance has been
created and the underlying method resolution order has been set.
The last example also illustrates the use of Python’s function signature objects. Essen‐
tially, the metaclass takes each callable definition in a class, searches for a prior definition
(if any), and then simply compares their calling signatures using inspect.signature().
Last, but not least, the line of code that uses super(self, self) is not a typo. When
working with a metaclass, it’s important to realize that the self is actually a class object.
So, that statement is actually being used to find definitions located further up the class
hierarchy that make up the parents of self.
9.18. Defining Classes Programmatically
Problem
You’re writing code that ultimately needs to create a new class object. You’ve thought
about emitting emit class source code to a string and using a function such as exec()
to evaluate it, but you’d prefer a more elegant solution.
Solution
You can use the function types.new_class() to instantiate new class objects. All you
need to do is provide the name of the class, tuple of parent classes, keyword arguments,
and a callback that populates the class dictionary with members. For example:
# stock.py
# Example of making a class manually from parts
# Methods
def __init__(selfnamesharesprice):
self.name = name
370  |  Chapter 9: Metaprogramming
self.shares = shares
self.price = price
def cost(self):
return self.shares * self.price
cls_dict = {
'__init__' : __init__,
'cost' : cost,
}
# Make a class
import types
Stock = types.new_class('Stock', (), {}, lambda nsns.update(cls_dict))
Stock.__module__ = __name__
This makes a normal class object that works just like you expect:
>>> s = Stock('ACME'5091.1)
>>> s
<stock.Stock object at 0x1006a9b10>
>>> s.cost()
4555.0
>>>
A subtle facet of the solution is the assignment to Stock.__module__ after the call to
types.new_class(). Whenever a class is defined, its __module__ attribute contains the
name of the module in which it was defined. This name is used to produce the output
made by methods such as __repr__(). It’s also used by various libraries, such as pick
le. Thus, in order for the class you make to be “proper,” you need to make sure this
attribute is set accordingly.
If the class you want to create involves a different metaclass, it would be specified in the
third argument to types.new_class(). For example:
>>> import abc
>>> Stock = types.new_class('Stock', (), {'metaclass'abc.ABCMeta},
...                         lambda nsns.update(cls_dict))
...
>>> Stock.__module__ = __name__
>>> Stock
<class '__main__.Stock'>
>>> type(Stock)
<class 'abc.ABCMeta'>
>>>
The third argument may also contain other keyword arguments. For example, a class
definition like this
class Spam(Basedebug=Truetypecheck=False):
...
9.18. Defining Classes Programmatically  |  371
would translate to a new_class() call similar to this:
Spam = types.new_class('Spam', (Base,),
{'debug'True'typecheck': False},
lambda ns: ns.update(cls_dict))
The fourth argument to new_class() is the most mysterious, but it is a function that
receives the mapping object being used for the class namespace as input. This is normally
a dictionary, but it’s actually whatever object gets returned by the __prepare__() meth‐
od, as described in Recipe 9.14. This function should add new entries to the namespace
using the update() method (as shown) or other mapping operations.
Discussion
Being able to manufacture new class objects can be useful in certain contexts. One of
the more familiar examples  involves  the collections.namedtuple() function.  For
example:
>>> Stock = collections.namedtuple('Stock', ['name''shares''price'])
>>> Stock
<class '__main__.Stock'>
>>>
namedtuple() uses exec() instead of the technique shown here. However, here is a
simple variant that creates a class directly:
import operator
import types
import sys
def named_tuple(classnamefieldnames):
# Populate a dictionary of field property accessors
cls_dict = { nameproperty(operator.itemgetter(n))
for nname in enumerate(fieldnames) }
# Make a __new__ function and add to the class dict
def __new__(cls*args):
if len(args!= len(fieldnames):
raise TypeError('Expected {} arguments'.format(len(fieldnames)))
return tuple.__new__(cls, args)
cls_dict['__new__'= __new__
# Make the class
cls = types.new_class(classname, (tuple,), {},
lambda ns: ns.update(cls_dict))
# Set the module to that of the caller
cls.__module__ = sys._getframe(1).f_globals['__name__']
return cls
372  |  Chapter 9: Metaprogramming
Documents you may be interested
Documents you may be interested