# Python: class StreamHandler

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.`