def __init__(self, crypter, negotiator):
        asynchat.async_chat.__init__(self)
        self.received_data = ''
        self.crypter = crypter
        self.negotiator = negotiator
        self.set_terminator(MessageManager.MULTI_MESSAGE_DELIMITER)
        self.negotiation_lock = mutex.mutex()
        self.progress_lock = mutex.mutex()
        self.in_step_through_mode = False
        self.shared_secret = ""
        self.integrity_hash = None

        self.logger = None
        self.debugger = None
        self.debugger_raw = None

 def __init__(self):
   try:
     self.mutex
   except:
     self.audioProxy = naoqi.ALProxy("ALAudioPlayer")        
     self.mutex = mutex.mutex()
     self.aSoundBank = {}

 def __init__(self, screen, num, image, sprites):
     """
     initialising
     :param screen: main view screen
     :param num: number of client
     :param image: image of player
     :param sprites: another objects in game
     :param players: another players
     :return:
     """
     self.active = False
     self.sprites = sprites
     self.movingright = False
     self.movingleft = False
     self.num = num
     self.__posx = random.randint(0, LENGTH_BOUND)
     self.__posy = random.randint(MAGIC_TWNT, HIGH_BOUND - DIST_DIFF)
     self.playerview = PlayerView(screen, self, image)
     self.dx = 0
     self.jumping = False
     self.jump_speed = 0
     self.jump_acceleration = 0
     self.landed = False
     self.died = False
     self.send_died = False
     self.score = 0
     self.onboard = False
     self.movingactions = dict()
     self.movingactions[LEFT] = self.lefthandler
     self.movingactions[RIGHT] = self.righthandler
     self.movingactions[JUMP] = self.jumphandler
     self.mutex = mutex.mutex()

def compare_all_files(file_name = 'file', magdir = 'Magdir', exact = False):
	pool = ThreadPool(4)
	m = mutex.mutex()

	split_patterns(magdir, file_name)
	compile_patterns(file_name)
	compiled = is_compilation_supported(file_name)

	entries = get_stored_files("db")

	def store_mimedata(data):
		metadata = get_full_metadata(data[0], file_name, compiled)
		stored_metadata = get_stored_metadata(data[0])
		text = "PASS " + data[0]
		if is_regression(stored_metadata, metadata, exact):
			text = "FAIL " + data[0] + "\n" + get_diff(stored_metadata, metadata, exact)
		return text

	def data_print(data):
		print data
		m.unlock()

	def data_stored(data):
		m.lock(data_print, data)

	for i,entry in enumerate(entries):
		# Insert tasks into the queue and let them run
		pool.queueTask(store_mimedata, (entry, i % 2), data_stored)

	# When all tasks are finished, allow the threads to terminate
	pool.joinAll()
	print ''

	def __init__(self):
		self.node_name = rospy.get_name()
		self.bridge = CvBridge()
		self.active = True
		self.config	= self.setupParam("~config", "baseline")
		self.cali_file_name = self.setupParam("~cali_file_name", "default")
		rospack = rospkg.RosPack()
		self.cali_file = rospack.get_path('duckietown') + \
				"/config/" + self.config + \
				"/vehicle_detection/vehicle_detection_node/" +  \
				self.cali_file_name + ".yaml"
		if not os.path.isfile(self.cali_file):
			rospy.logwarn("[%s] Can't find calibration file: %s.\n" 
					% (self.node_name, self.cali_file))
		self.loadConfig(self.cali_file)
		self.sub_image = rospy.Subscriber("~image", Image, 
				self.cbImage, queue_size=1)
		self.sub_switch = rospy.Subscriber("~switch", BoolStamped,
				self.cbSwitch, queue_size=1)
		self.pub_detection = rospy.Publisher("~detection", 
				BoolStamped, queue_size=1)
		self.pub_circlepattern_image = rospy.Publisher("~circlepattern_image", 
				Image, queue_size=1)
		self.pub_time_elapsed = rospy.Publisher("~detection_time",
			Float32, queue_size=1)
		self.lock = mutex()
		rospy.loginfo("[%s] Initialization completed" % (self.node_name))

 def __init__(self, value_type=None, py_value=None):
     self._del_mutex = mutex.mutex()
     GObjectModule.Value.__init__(self)
     if value_type is not None:
         self.init(value_type)
         if py_value is not None:
             self.set_value(py_value)

 def __init__(self):
     if( system.isOnNao() ):
         self.strFileName = "/home/nao/www/blog/index.html";
     elif( system.isOnWin32() ):
         self.strFileName = "D:/ApacheRootWebSite2/htdocs/naoblog/index.html";
     else:
         self.strFileName = "/www/blog";
         
     self.strImgFolderAbs = os.path.dirname( self.strFileName ) + "/img/";
     self.strImgFolderLocal = "img/";        
     self.strEmoFolderAbs = os.path.dirname( self.strFileName ) + "/emo/";
     self.strEmoFolderLocal = "emo/";
     
     self.logMutex = mutex.mutex();
     self.logLastTime = None;
     
     # constants:
     self.none = 0;
     self.happy = 1;
     self.sad = 2;
     self.proud = 3;
     self.excitement = 4;
     self.fear = 5;
     self.anger = 6;
     self.neutral = 7;
     self.hot= 8;

    def __init__(self, needed_caps):
        self._width = None
        self._height = None
        self._current_frame = None
        gobject.threads_init()
        self._mutex = mutex()
        gst.Bin.__init__(self)
        self._capsfilter = gst.element_factory_make('capsfilter', 'capsfilter')

        self.set_caps(needed_caps)
        self.add(self._capsfilter)
        
        fakesink = gst.element_factory_make('fakesink', 'fakesink')
        fakesink.set_property("sync", True)
        self.add(fakesink)
        self._capsfilter.link(fakesink)
        
        pad = self._capsfilter.get_pad("sink")
        ghostpad = gst.GhostPad("sink", pad)
        
        pad2probe = fakesink.get_pad("sink")
        pad2probe.add_buffer_probe(self.buffer_probe)

        self.add_pad(ghostpad)
        self.sink = self._capsfilter

 def __init__(self):
   try:
     self.mutex
   except:
     self.fm = naoqi.ALProxy("ALFrameManager")
     self.mutex = mutex.mutex()
     self.aLoaded = {}
     self.aRunning = {}

 def __init__(self):
     debug.debug( "INF: PersistentMemoryDataManager.__init__ called" );
     self.allData = {};
     self.mutexListData = mutex.mutex();
     try:
         os.makedirs( PersistentMemoryData.getVarPath() );
     except:
         pass # le dossier existe deja !

 def __init__(self) :
     self.map_data = {}
     self.building_names = {}
     self.map_mutex = mutex.mutex()
     for i in range(10000) :
         self.map_data[i] = UDMapEntry(i)
     self.load()
     self.load_types()

  def __init__(self, settings, camera):
    self.settings = settings
    self.camera = camera
    self.mutex = mutex.mutex()

    self.jancodes = []
    self.last_appear_time = time.time()
    self.shuttered = False

	def __init__(self):
		self.__cmdRegex = re.compile("(?P<qtype>who|what|where|when) (?P<verb>is|are|was|were) (?P<query>[^?]+)", re.I)
		self.__cacheFile = "googlism_cache"
		try: self.__cache = shelve.open(self.__cacheFile, protocol=2)
		except TypeError:
			# pre-2.3 didn't have a protocol argument.
			self.__cache = shelve.open(self.__cacheFile)
		self.__cacheMutex = mutex.mutex()
		self.__cacheKeys = self.__cache.keys()

 def __init__(self, eventTgt):
     logging.debug( 'Harmony __INIT__ ' )
     self._eventTgt = eventTgt
     threading.Thread.__init__(self)
     self.harmonySkt = None
     self.bufferedData = ""
     self.opened = False
     self.running = True
     self.mut = mutex.mutex()

def _install_restore_mode_child():
    global _mode_write_pipe
    global _restore_mode_child_installed

    if _restore_mode_child_installed:
        return

    # Parent communicates to child by sending "mode packets" through a pipe:
    mode_read_pipe, _mode_write_pipe = os.pipe()

    if os.fork() == 0:
        # Child process (watches for parent to die then restores video mode(s).
        os.close(_mode_write_pipe)

        # Set up SIGHUP to be the signal for when the parent dies.
        PR_SET_PDEATHSIG = 1
        libc = ctypes.cdll.LoadLibrary('libc.so.6')
        libc.prctl.argtypes = (ctypes.c_int, ctypes.c_ulong, ctypes.c_ulong,
                               ctypes.c_ulong, ctypes.c_ulong)
        libc.prctl(PR_SET_PDEATHSIG, signal.SIGHUP, 0, 0, 0)

        # SIGHUP indicates the parent has died.  The child mutex is unlocked, it
        # stops reading from the mode packet pipe and restores video modes on
        # all displays/screens it knows about.
        def _sighup(signum, frame):
            parent_wait_mutex.unlock()
        parent_wait_mutex = mutex.mutex()
        parent_wait_mutex.lock(lambda arg: arg, None)
        signal.signal(signal.SIGHUP, _sighup)

        # Wait for parent to die and read packets from parent pipe
        packets = []
        buffer = ''
        while parent_wait_mutex.test():
            try:
                data = os.read(mode_read_pipe, ModePacket.size)
                buffer += data
                # Decode packets
                while len(buffer) >= ModePacket.size:
                    packet = ModePacket.decode(buffer[:ModePacket.size])
                    packets.append(packet)
                    buffer = buffer[ModePacket.size:]
            except OSError:
                pass # Interrupted system call

        for packet in packets:
            packet.set()
        os._exit(0)
        
    else:
        # Parent process.  Clean up pipe then continue running program as
        # normal.  Send mode packets through pipe as additional
        # displays/screens are mode switched.
        os.close(mode_read_pipe)
        _restore_mode_child_installed = True

	def __init__(self):
		self.node_name = "Image Average"
		self.bridge = CvBridge()
		self.pub_image = rospy.Publisher("~average_image", Image, queue_size=1)
		self.sub_image = rospy.Subscriber("/ferrari/camera_node/image/compressed", CompressedImage, 
				self.cbImage, queue_size=1)
		rospy.loginfo("Initialization of [%s] completed" % (self.node_name))
		self.lock = mutex()
		self.lock.unlock()
		self.avg_img = None
		self.count_images = 0

 def __init__(self):
     print('intiailizing processing')
     self.gpsmutex = mutex()
     self.estmutex = mutex()
     self.attmutex = mutex()
     self.radarmutex = mutex()
     self.radarmsgavailable = False
     self.gpsavail = threading.Event()
     self.estavail = threading.Event()
     self.attavail = threading.Event()
     self.radarupdate = threading.Event()
     self.att = None
     self.est = None
     self.gps = None
     self.lastatt = None
     self.lastest = None
     self.lastgps = None
     self.I = None
     self.lastI = None
     self.radarmsgavailable = False
     self.shutdown = False

def test_all_files(exact=False, binary="file"):
    """Compare output of given file(1) binary with db for all entries."""
    global ret
    ret = 0

    print_file_info(binary)

    print_lock = mutex.mutex()

    entries = sorted(get_stored_files("db"))

    def store_mimedata(filename):
        """Compare file(1) output with db for single entry."""
        metadata = get_simple_metadata(filename, binary)
        try:
            stored_metadata = get_stored_metadata(filename)
        except IOError:
            # file not found or corrupt
            text = "FAIL " + filename + "\n" + \
                   "FAIL   could not find stored metadata!\n" + \
                   "This can mean that the File failed to generate " + \
                   "any output for this file."
        else:
            text = "PASS " + filename
            if is_regression(stored_metadata, metadata, exact):
                text = "FAIL " + filename + "\n" + \
                       get_diff(stored_metadata, metadata, exact)
        return text

    def data_print(data):
        """Print given text, set global return value, unlock print lock."""
        print(data)
        if data[0] == "F":
            global ret
            ret = 1
        print_lock.unlock()

    def data_stored(data):
        """Acquire print lock and call :py:function:`data_print`."""
        print_lock.lock(data_print, data)

    # create here so program exits if error occurs earlier
    n_threads = 1
    pool = ThreadPool(n_threads)

    for entry in entries:
        # Insert tasks into the queue and let them run
        pool.queueTask(store_mimedata, entry, data_stored)

    # When all tasks are finished, allow the threads to terminate
    pool.joinAll()
    print('')
    return ret

    def __init__(self, parent):
        """クラスの初期化


        [引数]
        parent -- 親クラス

        [戻り値]
        void
        """
        RtmDictCore.__init__(self, parent)
        self.parent = parent
        self.Mutex = mutex.mutex()

	def __init__(self, name, notebook):
		wx.PyLog.__init__(self)
		self.tc = wx.TextCtrl(notebook, -1, style = wx.TE_MULTILINE|wx.TE_READONLY)
		self.logTime = True
		self.mutex = mutex.mutex() #control access to text controls
		self.name = name
		try:
			os.mkdir('logs')
		except OSError:
			#directory already exists
			pass
			
		self.filename = 'logs/'+time.strftime("%Y%m%d-%H%M")+self.name+'.txt'
		self.logfile_opened = False