start.StreamHandler = class StreamHandler(threading.Thread)
`` | `this class can receive files sent by p2p to run this class, we need to do : s = StreamHandler(portFile, fileName) s.start()`
| Method resolution order: StreamHandler threading.Thread builtins.object Methods defined here: __init__(self, port, filename) `:param port: the port of the new connection :param filename: the name of the file you wish to receive :return:` acceptcsock(self) `accept to receive the file :return:` acceptmsock(self) `Get the address of the connection :return:` bindmsock(self) `creation of a new socket for the p2p transfert file :return:` close(self) `We close the connection :return:` process(self) `function who start all the function :return:` run(self) `Execute the process function :return:` transfer(self) `Starting the transfert of the file :return:` Methods inherited from threading.Thread: __repr__(self) getName(self) isAlive = is_alive(self) `Return whether the thread is alive. This method returns True just before the run() method starts until just after the run() method terminates. The module function enumerate() returns a list of all alive threads.` isDaemon(self) is_alive(self) `Return whether the thread is alive. This method returns True just before the run() method starts until just after the run() method terminates. The module function enumerate() returns a list of all alive threads.` join(self, timeout=None) `Wait until the thread terminates. This blocks the calling thread until the thread whose join() method is called terminates -- either normally or through an unhandled exception or until the optional timeout occurs. When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof). As join() always returns None, you must call isAlive() after join() to decide whether a timeout happened -- if the thread is still alive, the join() call timed out. When the timeout argument is not present or None, the operation will block until the thread terminates. A thread can be join()ed many times. join() raises a RuntimeError if an attempt is made to join the current thread as that would cause a deadlock. It is also an error to join() a thread before it has been started and attempts to do so raises the same exception.` setDaemon(self, daemonic) setName(self, name) start(self) `Start the thread's activity. It must be called at most once per thread object. It arranges for the object's run() method to be invoked in a separate thread of control. This method will raise a RuntimeError if called more than once on the same thread object.` Data descriptors inherited from threading.Thread: __dict__ `dictionary for instance variables (if defined)` __weakref__ `list of weak references to the object (if defined)` daemon `A boolean value indicating whether this thread is a daemon thread. This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False. The entire Python program exits when no alive non-daemon threads are left.` ident `Thread identifier of this thread or None if it has not been started. This is a nonzero integer. See the thread.get_ident() function. Thread identifiers may be recycled when a thread exits and another thread is created. The identifier is available even after the thread has exited.` name `A string used for identification purposes only. It has no semantics. Multiple threads may be given the same name. The initial name is set by the constructor.`