convert pdf to image c# ghostscript : Change pdf document security software SDK dll winforms .net azure web forms Official%20Python%20Manual%20of%20Python%202.7.6%20164-part1586

index
modules |
next |
previous |
17.5. 
popen2
— Subprocesses with accessible
I/O streams
Deprecated since version 2.6: This module is obsolete. Use the 
subprocess
module.
Check especially the Replacing Older Functions with the subprocess Module section.
This module allows you to spawn processes and connect to their input/output/error pipes
and obtain their return codes under Unix and Windows.
The 
subprocess
module provides more powerful facilities for spawning new processes
and  retrieving  their  results. Using  the 
subprocess
module is preferable to using the
popen2
module.
The primary interface offered by this module is a trio of factory functions. For each of
these,  if bufsize  is  specified, it  specifies the  buffer size for  the I/O  pipes. mode,  if
provided, should be the string 
'b'
or 
't'
; on Windows this is needed to determine
whether the file objects should be opened in binary or text mode. The default value for
mode is 
't'
.
On Unix, cmd may be a sequence, in which case arguments will be passed directly to the
program without shell intervention (as with 
os.spawnv()
).  If cmd is a string it will be
passed to the shell (as with 
os.system()
).
The only way to retrieve the return codes for the child processes is by using the 
poll()
or 
wait()
methods on the 
Popen3
and 
Popen4
classes; these are only available on Unix.
This  information  is  not available  when  using the 
popen2()
popen3()
 and 
popen4()
functions, or the equivalent functions in the 
os
module. (Note that the tuples returned by
the 
os
module’s functions are in a different order from the ones returned by the 
popen2
module.)
popen2.
popen2
(
cmd
[
, bufsize
[
, mode
]]
)
Executes cmd  as  a  sub-process. Returns  the  file  objects 
(child_stdout,
child_stdin)
.
popen2.
popen3
(
cmd
[
, bufsize
[
, mode
]]
)
Executes cmd  as  a  sub-process. Returns  the  file  objects 
(child_stdout,
Python » Python v2.7.6 documentation » The Python Standard Library » 17. Interprocess
Communication and Networking »
Change pdf document security - 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
add security to pdf in reader; decrypt pdf file online
Change pdf document security - 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
convert locked pdf to word doc; secure pdf
child_stdin, child_stderr)
.
popen2.
popen4
(
cmd
[
, bufsize
[
, mode
]]
)
Executes cmd as a sub-process. Returns the file objects 
(child_stdout_and_stderr,
child_stdin)
.
New in version 2.0.
On Unix, a class defining the objects returned by the factory functions is also available.
These are not used for the Windows implementation, and are not available on that
platform.
class 
popen2.
Popen3
(
cmd
[
, capturestderr
[
, bufsize
]]
)
This class represents a child process. Normally, 
Popen3
instances are created using
the 
popen2()
and 
popen3()
factory functions described above.
If not using one of the helper functions to create 
Popen3
objects, the parameter cmd is
the shell  command  to execute  in  a sub-process. The capturestderr  flag,  if  true,
specifies that the object should capture standard error output of the child process.
The default is false. If the bufsize parameter is specified, it specifies the size of the
I/O buffers to/from the child process.
class 
popen2.
Popen4
(
cmd
[
, bufsize
]
)
Similar  to 
Popen3
, but always captures standard error into the same file object as
standard output. These are typically created using 
popen4()
.
New in version 2.0.
17.5.1. Popen3 and Popen4 Objects
Instances of the 
Popen3
and 
Popen4
classes have the following methods:
Popen3.
poll
()
Returns 
-1
if child process hasn’t completed yet, or its status code (see 
wait()
)
otherwise.
Popen3.
wait
()
Waits for and returns the status code of the child process. The status code encodes
both the return code of the process and information about whether it exited using the
exit()
system call or died due to a signal. Functions to help interpret the status code
are defined in the 
os
module; see section Process Management for the 
W*()
family of
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. Change PDF original password.
pdf password security; pdf security settings
Online Split PDF file. Best free online split PDF tool.
our .NET PDF SDK to set file split settings for your PDF document in Visual You can receive the PDF files by simply clicking download and you are Web Security.
change security on pdf; change pdf security settings reader
functions.
The following attributes are also available:
Popen3.
fromchild
A file object that provides output from the child process. For 
Popen4
instances, this will
provide both the standard output and standard error streams.
Popen3.
tochild
A file object that provides input to the child process.
Popen3.
childerr
A file object that provides error output from the child process, if capturestderr was
true  for  the  constructor,  otherwise 
None
 This  will  always  be 
None
for 
Popen4
instances.
Popen3.
pid
The process ID of the child process.
17.5.2. Flow Control Issues
Any time you are working with any form of inter-process communication, control flow
needs to be carefully thought out. This remains the case with the file objects provided by
this module (or the 
os
module equivalents).
When reading output from a child process that writes a lot of data to standard error while
the parent is reading from the child’s standard output, a deadlock can occur. A similar
situation can occur with other combinations of reads and writes. The essential factors are
that  more  than 
_PC_PIPE_BUF
bytes are being written by one process in a blocking
fashion, while the other process is reading from the first process, also in a blocking
fashion.
There are several ways to deal with this situation.
The simplest application change, in many cases, will be to follow this model in the parent
process:
import popen2
r, w, e = popen2.popen3('python slave.py')
e.readlines()
r.readlines()
r.close()
e.close()
w.close()
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.
decrypt a pdf file online; pdf password unlock
Online Change your PDF file Permission Settings
SDK to set file permissions for your PDF document in Visual to make it as easy as possible to change your PDF You can receive the locked PDF by simply clicking
pdf secure; convert secure pdf to word
with code like this in the child:
import os
import sys
# note that each of these print statements
# writes a single long string
print >>sys.stderr, 400 * 'this is a test\n'
os.close(sys.stderr.fileno())
print >>sys.stdout, 400 * 'this is another test\n'
In particular, note that 
sys.stderr
must be closed after writing all data, or 
readlines()
won’t  return. Also  note  that 
os.close()
must be used, as 
sys.stderr.close()
won’t
close 
stderr
(otherwise assigning to 
sys.stderr
will silently close it, so no further errors
can be printed).
Applications which need to support a more general approach should integrate I/O over
pipes with their 
select()
loops, or use separate threads to read each of the individual
files provided by whichever 
popen*()
function or 
Popen*
class was used.
See also:
Module 
subprocess
Module for spawning and managing subprocesses.
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » The Python Standard Library » 17. Interprocess
Communication and Networking »
© 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.
C# HTML5 Viewer: Deployment on AzureCloudService
RasterEdge.XDoc.PDF.HTML5Editor.dll. system.webServer> <validation validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
decrypt pdf password; decrypt pdf
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.
change security settings on pdf; create secure pdf online
index
modules |
next |
previous |
17.6. 
asyncore
— Asynchronous socket handler
Source code: Lib/asyncore.py
This module provides the basic infrastructure for writing asynchronous socket service
clients and servers.
There are only two ways to have a program on a single processor do “more than one
thing at a time.” Multi-threaded programming is the simplest and most popular way to do
it,  but  there  is  another  very  different  technique,  that  lets  you  have  nearly  all  the
advantages  of multi-threading, without actually using  multiple  threads. It’s  really only
practical if your program is largely I/O bound. If your program is processor bound, then
pre-emptive scheduled threads are probably what you really need. Network servers are
rarely processor bound, however.
If your operating system supports the 
select()
system call in its I/O library (and nearly
all do), then you can use it to juggle multiple communication channels at once; doing
other work while your I/O is taking place in the “background.” Although this strategy can
seem strange and complex, especially at first, it is in many ways easier to understand
and control than multi-threaded programming. The 
asyncore
module solves many of the
difficult problems for you, making the task of building sophisticated high-performance
network servers and clients a snap. For “conversational” applications and protocols the
companion 
asynchat
module is invaluable.
The  basic  idea  behind  both  modules  is  to  create  one  or  more  network channels,
instances  of  class 
asyncore.dispatcher
and 
asynchat.async_chat
 Creating  the
channels adds them to a global map, used by the 
loop()
function if you do not provide it
with your own map.
Once the initial channel(s) is(are) created, calling the 
loop()
function activates channel
service, which continues until the last channel (including any that have been added to the
map during asynchronous service) is closed.
asyncore.
loop
(
[
timeout
[
, use_poll
[
, map
[
, count
]]]]
)
Enter a polling loop that terminates after count passes or all open channels have been
closed. All arguments are optional. The count parameter defaults to None, resulting in
the loop terminating only when all channels have been closed. The timeout argument
sets the timeout parameter for the appropriate 
select()
or 
poll()
call, measured in
Python » Python v2.7.6 documentation » The Python Standard Library » 17. Interprocess
Communication and Networking »
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
Security PDF component download. Online source codes for quick evaluation in VB.NET class. A good external PDF document page(s) extraction tool should be highly
change pdf document security properties; change pdf security settings
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
decrypt pdf password online; pdf password encryption
seconds; the default is 30 seconds. The use_poll parameter, if true, indicates that
poll()
should be used in preference to 
select()
(the default is 
False
).
The map  parameter is a dictionary  whose  items are the channels to watch. As
channels are closed they are deleted from their map. If map is omitted, a global map
is  used.  Channels  (instances  of 
asyncore.dispatcher
asynchat.async_chat
and
subclasses thereof) can freely be mixed in the map.
class 
asyncore.
dispatcher
The 
dispatcher
class is a thin wrapper around a low-level socket object. To make it
more useful, it has a few methods for event-handling which are called from the
asynchronous  loop. Otherwise, it can be treated as a normal non-blocking socket
object.
The firing of low-level events at certain times or in certain connection states tells the
asynchronous loop that certain higher-level events have taken place. For example, if
we have asked for a socket to connect to another host, we know that the connection
has been made when the socket becomes writable for the first time (at this point you
know that you may write to it with the expectation of success). The implied higher-
level events are:
Event
Description
handle_connect()
Implied by the first read or write event
handle_close()
Implied by a read event with no data
available
handle_accept()
Implied by a read event on a listening socket
During  asynchronous  processing,  each  mapped  channel’s 
readable()
and
writable()
methods are used to determine whether the channel’s socket should be
added to the list of channels 
select()
ed or 
poll()
ed for read and write events.
Thus, the set of channel events is larger than the basic socket events. The full set of
methods that can be overridden in your subclass follows:
handle_read
()
Called when the asynchronous loop detects that a 
read()
call on the channel’s
socket will succeed.
handle_write
()
Called when the asynchronous loop detects that a writable socket can be written.
Often this method will implement the necessary buffering for performance. For
example:
def handle_write(self):
sent = self.send(self.buffer)
self.buffer = self.buffer[sent:]
handle_expt
()
Called when there is out of band (OOB) data for a socket connection. This will
almost never happen, as OOB is tenuously supported and rarely used.
handle_connect
()
Called when the active opener’s socket actually makes a connection. Might send a
“welcome” banner, or initiate a protocol negotiation with the remote endpoint, for
example.
handle_close
()
Called when the socket is closed.
handle_error
()
Called when an exception is raised and not otherwise handled. The default version
prints a condensed traceback.
handle_accept
()
Called  on  listening  channels  (passive  openers)  when  a  connection  can  be
established with a new remote endpoint that has issued a 
connect()
call for the
local endpoint.
readable
()
Called each time around the asynchronous loop to determine whether a channel’s
socket should be added to the list on which read events can occur. The default
method  simply  returns 
True
 indicating  that  by  default,  all  channels  will  be
interested in read events.
writable
()
Called each time around the asynchronous loop to determine whether a channel’s
socket should be added to the list on which write events can occur. The default
method  simply  returns 
True
 indicating  that  by  default,  all  channels  will  be
interested in write events.
In addition, each channel delegates or extends many of the socket methods. Most of
these are nearly identical to their socket partners.
create_socket
(
family, type
)
This is identical to the creation of a normal socket, and will use the same options
for  creation. Refer  to  the 
socket
documentation  for  information  on  creating
sockets.
connect
(
address
)
As with the normal socket object, address is a tuple with the first element the host
to connect to, and the second the port number.
send
(
data
)
Send data to the remote end-point of the socket.
recv
(
buffer_size
)
Read at  most buffer_size bytes from the socket’s remote end-point. An empty
string implies that the channel has been closed from the other end.
listen
(
backlog
)
Listen for connections made to the socket. The backlog argument specifies the
maximum number of queued connections and should be at least 1; the maximum
value is system-dependent (usually 5).
bind
(
address
)
Bind the socket to address. The socket must not already be bound. (The format of
address depends on the address family — refer to the 
socket
documentation for
more  information.) To mark the socket as re-usable (setting the 
SO_REUSEADDR
option), call the 
dispatcher
object’s 
set_reuse_addr()
method.
accept
()
Accept a connection. The socket must be bound to an address and listening for
connections. The return value can be either 
None
or a pair 
(conn, address)
where
conn is a new socket object usable to send and receive data on the connection,
and address  is  the  address  bound  to  the  socket  on  the  other  end  of  the
connection. When 
None
is returned it means the connection didn’t take place, in
which case the server should just ignore this event and keep listening for further
incoming connections.
close
()
Close the socket. All future operations on the socket object will fail. The remote
end-point will receive no more data (after queued data is flushed). Sockets are
automatically closed when they are garbage-collected.
class 
asyncore.
dispatcher_with_send
dispatcher
subclass which adds simple buffered output capability, useful for simple
clients. For more sophisticated usage use 
asynchat.async_chat
.
class 
asyncore.
file_dispatcher
A file_dispatcher takes a file descriptor or file object along with an optional map
argument and wraps it for use with the 
poll()
or 
loop()
functions. If provided a file
object or anything with a 
fileno()
method, that method will be called and passed to
the 
file_wrapper
constructor. Availability: UNIX.
class 
asyncore.
file_wrapper
A file_wrapper takes an integer file descriptor and calls 
os.dup()
to duplicate the
handle so that the original handle may be closed independently of the file_wrapper.
This  class  implements  sufficient  methods  to  emulate  a  socket  for  use  by  the
file_dispatcher
class. Availability: UNIX.
17.6.1. asyncore Example basic HTTP client
Here is a very basic HTTP client that uses the 
dispatcher
class to implement its socket
handling:
import asyncore, socket
class HTTPClient(asyncore.dispatcher):
def __init__(self, host, path):
asyncore.dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.connect( (host, 80) )
self.buffer = 'GET %s HTTP/1.0\r\n\r\n' % path
def handle_connect(self):
pass
def handle_close(self):
self.close()
def handle_read(self):
print self.recv(8192)
def writable(self):
return (len(self.buffer) > 0)
def handle_write(self):
sent = self.send(self.buffer)
self.buffer = self.buffer[sent:]
client = HTTPClient('www.python.org''/')
asyncore.loop()
17.6.2. asyncore Example basic echo server
Here is a basic echo server that uses the 
dispatcher
class to accept connections and
dispatches the incoming connections to a handler:
import asyncore
import socket
class EchoHandler(asyncore.dispatcher_with_send):
def handle_read(self):
data = self.recv(8192)
if data:
self.send(data)
class EchoServer(asyncore.dispatcher):
def __init__(self, host, port):
asyncore.dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((host, port))
self.listen(5)
def handle_accept(self):
pair = self.accept()
if pair is not None:
sock, addr = pair
print 'Incoming connection from %s' % repr(addr)
handler = EchoHandler(sock)
server = EchoServer('localhost'8080)
asyncore.loop()
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » The Python Standard Library » 17. Interprocess
Communication and Networking »
© 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.
Documents you may be interested
Documents you may be interested