def __init__(self):
        FileSystemEventHandler.__init__(self)	# futureproofing - not need for current version of watchdog
        self.root = None
        self.currentdir = None		# The actual logdir that we're monitoring
        self.logfile = None
        self.observer = None
        self.observed = None		# a watchdog ObservedWatch, or None if polling
        self.thread = None
        self.event_queue = []		# For communicating journal entries back to main thread

        # On startup we might be:
        # 1) Looking at an old journal file because the game isn't running or the user has exited to the main menu.
        # 2) Looking at an empty journal (only 'Fileheader') because the user is at the main menu.
        # 3) In the middle of a 'live' game.
        # If 1 or 2 a LoadGame event will happen when the game goes live.
        # If 3 we need to inject a special 'StartUp' event since consumers won't see the LoadGame event.
        self.live = False

        self.game_was_running = False	# For generation the "ShutDown" event

        # Context for journal handling
        self.version = None
        self.is_beta = False
        self.mode = None
        self.group = None
        self.cmdr = None
        self.planet = None
        self.system = None
        self.station = None
        self.stationtype = None
        self.coordinates = None
        self.systemaddress = None
        self.started = None	# Timestamp of the LoadGame event

        # Cmdr state shared with EDSM and plugins
        self.state = {
            'Captain'      : None,	# On a crew
            'Cargo'        : defaultdict(int),
            'Credits'      : None,
            'FID'          : None,	# Frontier Cmdr ID
            'Horizons'     : None,	# Does this user have Horizons?
            'Loan'         : None,
            'Raw'          : defaultdict(int),
            'Manufactured' : defaultdict(int),
            'Encoded'      : defaultdict(int),
            'Engineers'    : {},
            'Rank'         : {},
            'Reputation'   : {},
            'Statistics'   : {},
            'Role'         : None,	# Crew role - None, Idle, FireCon, FighterCon
            'Friends'      : set(),	# Online friends
            'ShipID'       : None,
            'ShipIdent'    : None,
            'ShipName'     : None,
            'ShipType'     : None,
            'HullValue'    : None,
            'ModulesValue' : None,
            'Rebuy'        : None,
            'Modules'      : None,
        }

 def __init__(self, path, mask, callbacks, pending_delay):
     FileSystemEventHandler.__init__(self)
     self._path = path
     self._mask = mask
     self._callbacks = callbacks
     self._pending_delay = pending_delay
     self._pending = set()

def watch_note(note, handle_func):
    """watch a single note for changes,
    call `handle_func` on change"""
    ob = Observer()
    handler = FileSystemEventHandler()
    note_filename = path.basename(note)

    def handle_event(event):
        _, filename = path.split(event.src_path)
        if note_filename == filename or \
                path.normpath(event.src_path) == path.normpath(util.assets_dir(note)):
            print('compiling...')
            handle_func(note)
            print('done')
    handler.on_any_event = handle_event

    print('watching "{0}"...'.format(note_filename))
    ob.schedule(handler, path.dirname(note), recursive=True)
    ob.start()

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print('stopping...')
        ob.stop()
    ob.join()

    def __init__(self, monitor_dir, config):
        FileSystemEventHandler.__init__(self)

        self.monitor_dir = monitor_dir
        if not config: config = {}

        self.scan_interval = config.get('scan_interval', 3) # If no updates in 3 seconds (or user specified option in config file) process file

    def __init__(self, holder, configfile, *args, **kwargs):
        FileSystemEventHandler.__init__(self, *args, **kwargs)
        self._file = None
        self._filename = ""
        self._where = 0
        self._satellite = ""
        self._orbital = None
        cfg = ConfigParser()
        cfg.read(configfile)
        self._coords = cfg.get("local_reception", "coordinates").split(" ")
        self._coords = [float(self._coords[0]),
                        float(self._coords[1]),
                        float(self._coords[2])]
        self._station = cfg.get("local_reception", "station")
        logger.debug("Station " + self._station +
                     " located at: " + str(self._coords))
        try:
            self._tle_files = cfg.get("local_reception", "tle_files")
        except NoOptionError:
            self._tle_files = None

        self._file_pattern = cfg.get("local_reception", "file_pattern")
        
        self.scanlines = holder

        self._warn = True

def watch_note(note, handle_func):
    """watch a single note for changes,
    call `handle_func` on change"""
    ob = Observer()
    handler = FileSystemEventHandler()

    def handle_event(event):
        """update the note only if:
            - the note itself is changed
            - a referenced asset is changed
        """
        _, filename = os.path.split(event.src_path)

        # get all absolute paths of referenced images
        images = []
        for img_path in note.images:
            if not os.path.isabs(img_path):
                img_path = os.path.join(note.dir, img_path)
            images.append(img_path)

        if note.filename == filename or event.src_path in images:
            handle_func(note)
    handler.on_any_event = handle_event

    print('watching {0}...'.format(note.title))
    ob.schedule(handler, note.dir, recursive=True)
    ob.start()

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print('stopping...')
        ob.stop()
    ob.join()

 def __init__(self):
     FileSystemEventHandler.__init__(self)	# futureproofing - not need for current version of watchdog
     self.root = None
     self.currentdir = None		# The actual logdir that we're monitoring
     self.observer = None
     self.observed = None		# a watchdog ObservedWatch, or None if polling
     self.status = {}		# Current status for communicating status back to main thread

 def __init__(self, *args, **kwargs):
     self.rate = 4
     self.surface = pygame.Surface((1, 1))
     self.size = (0, 0)
     self.fade = False
     self.screensize = kwargs.pop("screensize")
     FileSystemEventHandler.__init__(self, *args, **kwargs)

 def __init__(self, paths, forkloop, minimum_wait=2.0):
     FileSystemEventHandler.__init__(self)
     self.forkloop = forkloop
     self.observers = []
     self.paths = paths
     self.minimum_wait = minimum_wait
     self.last_event = time.time()

 def __init__(self, project_id, handler_type='project'):
     # Initialize.
     self.project_id = project_id
     FileSystemEventHandler.__init__(self)
     # Handler is a project file handler...
     if handler_type == 'project':
         log_msg = ('PROJECT_EVENT_HANDLER initialized for project '
                    'with ID {project_id}')
         self.actions = {
             'Created': self._on_created_project,
             'Deleted': self._on_deleted_project,
             'Modified': self._on_modified_project,
             'Moved': self._on_moved_project
         }
     # Handler is a project scanner handler.
     elif handler_type == 'scanner':
         log_msg = ('Project image scan handler initialized for project '
                    'with ID {project_id}')
         self.actions = {'Created': self._on_created_scanner}
     # Undefined handler type.
     else:
         raise NotImplementedError()
     # Populate the log_mgs with data and log.
     log_msg = log_msg.format(**self.__dict__)
     _logger().debug(log_msg)

 def __init__(self):
     """
     Constructor
     :return:
     """
     FileSystemEventHandler.__init__(self)
     self.app = app._get_current_object()

	def __init__(self):
		self.watcher_pid_file = os.path.join(MONITOR_ROOT, "watcher.pid.txt")
		self.watcher_log_file = os.path.join(MONITOR_ROOT, "watcher.log.txt")

		self.annex_observer = Observer()
		self.netcat_queue = []
		self.cleanup_upload_lock = False

		FileSystemEventHandler.__init__(self)

 def __init__(self):
     FileSystemEventHandler.__init__(self)	# futureproofing - not need for current version of watchdog
     self.root = None
     self.logdir = self._logdir()
     self.logfile = None
     self.observer = None
     self.thread = None
     self.callback = None
     self.last_event = None	# for communicating the Jump event

 def on_modified(self, event):
     '''
     @summary:
     ファイル更新時イベント
     ファイルのときはインデックス更新
     ディレクトリのときはファイルが追加されたときとかそういうイベントなので、無視
     '''
     if not event.is_directory:
         self.refresh_file(event.src_path)
     FileSystemEventHandler.on_created(self, event)

        def __init__(self, patterns, observer_class_name="Observer"):
            FileSystemEventHandler.__init__(self)
            self.input_dirs = []
            for pattern in patterns:
                self.input_dirs.append(os.path.dirname(pattern))
                LOG.debug("watching " + str(os.path.dirname(pattern)))
            self.patterns = patterns

            self.new_file = Event()
            self.observer = self.cases.get(observer_class_name, Observer)()

        def __init__(self, collectors, terminator, decoder, patterns, observer_class_name):
            FileSystemEventHandler.__init__(self)
            FileTrigger.__init__(self, collectors, terminator, decoder)
            self.input_dirs = []
            for pattern in patterns:
                self.input_dirs.append(os.path.dirname(pattern))
            self.patterns = patterns

            self.new_file = Event()
            self.observer = self.cases.get(observer_class_name, Observer)()

 def on_deleted(self, event):
     '''
     @summary: ファイル削除イベント
     '''
     if event.is_directory:
         pass
     else:
         self.watcher.index.remove([event.src_path])
     logger.debug("DELETE %s" % event.src_path)
     FileSystemEventHandler.on_deleted(self, event)

 def __init__(self):
     FileSystemEventHandler.__init__(self)	# futureproofing - not need for current version of watchdog
     self.root = None
     self.logdir = self._logdir()
     self.logfile = None
     self.logging_enabled = self._logging_enabled
     self._restart_required = False
     self.observer = None
     self.thread = None
     self.last_event = None	# for communicating the Jump event

    def __init__(self, exit, input_directory, output_directory, output_directory_tmp, loop=None, **kwargs):
        self._exit = exit
        self._loop = loop
        self._input_directory = input_directory
        self._output_directory = (output_directory_tmp, output_directory)

        logging.info('From directory is ' + input_directory)
        logging.info('To directory is ' + output_directory)

        AIOEventHandler.__init__(self, loop)
        FileSystemEventHandler.__init__(self, **kwargs)

 def __init__(self, dirname, record_source, loglevel):
     FileSystemEventHandler.__init__(self)
     self.dirname = dirname
     if not os.path.isdir(self.dirname + constants.TMP_FOLDER): 
         os.mkdir(self.dirname + constants.TMP_FOLDER)
     self.changes = {}
     self.just_changed = {}
     self.valid = re.compile(r'^(\./)?([^/]+/)*(?!\.)[^/]*[^~]$') #PE test this, should work
     #self.valid = re.compile(r'^(.+/)*[^\./][^/~]*$')
     self.record_source = record_source
     self.loglevel = loglevel