def __init__(self, db_handler):
'''
Args:
db_handler: An object of Db.DbHandler
'''
FileSystemEventHandler.__init__(self)
self._db_handler = db_handler
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):
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
# Context for journal handling
self.version = None
self.is_beta = False
self.mode = None
self.group = None
self.cmdr = None
self.shipid = None
self.shiptype = None
self.shippaint = None
self.body = None
self.system = None
self.station = None
self.coordinates = None
self.ranks = None
self.credits = None
def __init__(self, fun, publisher, pattern, attrs):
"""Initialize the processor."""
FileSystemEventHandler.__init__(self)
self.fun = fun
self.publisher = publisher
self.pattern = pattern
self.attrs = attrs
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
self.missioncargo = {} # For tracking cargo in wing missions
# Cmdr state shared with EDSM and plugins
self.state = {
'Captain': None, # On a crew
'Cargo': defaultdict(int),
'Credits': None,
'Loan': None,
'Raw': defaultdict(int),
'Manufactured': defaultdict(int),
'Encoded': defaultdict(int),
'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, library, path, xbmcif):
FileSystemEventHandler.__init__(self)
self.library = library
self.path = path
self.xbmcif = xbmcif
self.supported_media = '|' + py2_decode(
xbmc.getSupportedMedia(library)) + '|'
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, *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):
"""
Constructor
:return:
"""
FileSystemEventHandler.__init__(self)
self.app = app._get_current_object()
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, 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, 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 __init__(self):
FileSystemEventHandler.__init__(self)
super().__init__()
self.locked_groups = []
try:
pass
self.load_state()
self.displaygen()
except:
self.display = ""
self.groups = []
self.monitors = {}
monitors = command("bspc query -M --names").strip().split("\n")
for monitor in monitors:
self.monitors[monitor] = []
workspaces = command("bspc query -D -m " + monitor +
" --names").strip().split("\n")
command("bspc desktop -f " + workspaces[0])
self.groups.append(Group())
self.activegroup = self.groups[-1]
self.activegroup.workspaces = [
workspace for workspace in workspaces
]
try:
command("rm {}*".format(config["command_folder"]))
except:
pass
self.displaygen()
def __init__(self, file_path, window):
FileSystemEventHandler.__init__(self)
self.file_path = os.path.normpath(file_path)
self.last_position = 0
self.signal = None
self.signal = window.new_window
self.ProcessCommands()
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 __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, file_path, host="192.168.1.25", port=1234):
FileSystemEventHandler.__init__(self)
self.file_path = file_path
self._host = host
self._port = port
self._regex = re.compile(r"^(?P<artist>.*) - (?P<title>.*)$")
self._last_sent = time.time()
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 __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, 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 __init__(self, name, queue):
FileSystemEventHandler.__init__(self)
self.name = name
self.queue = queue
self.set = set()
self.num = 0
self.no = 0
def __init__(self, parent, *args, **kwargs):
QtCore.QObject.__init__(self, parent)
FileSystemEventHandler.__init__(self, *args, **kwargs)
Tester.__init__(self)
self.parent = parent
self.signfilelistupdate.connect(self.parent.updateWatchdogFileList)
def __init__(self, filepath): # type: (str)
warn("Attribute currentConfig will be replaced with property"
"current_config. Use current_config instead.")
FileSystemEventHandler.__init__(self)
self.filepath = filepath
self.current_config = None
def __init__(self, origin, watch_path, event_func):
FileSystemEventHandler.__init__(self)
self.origin = origin
self.watch_path = watch_path
self.event_func = event_func
self.observer = Observer()
self.watch = None
self.mutex = threading.Lock()
def __init__(self):
FileSystemEventHandler.__init__(self)
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] [%(name)s] %(message)s")
self._logger = logging.getLogger(self.__class__.__name__)
self._create_pid_file(os.path.dirname(__file__))
self._register_signal()
self.__last_modify_timestamp = time.time()
self.__observer = Observer()
def __init__(self, bucket, rootkey=None,
sizetrigger=8*1024*1024, timetrigger=5):
_FileSystemEventHandler.__init__(self)
self._bucket = bucket
self._rootkey = rootkey
self._sizetrigger = int(sizetrigger)
self._timetrigger = int(timetrigger)
self._files = {}
def __init__(self, args, names, tax, class_number):
FileSystemEventHandler.__init__(self)
self.tax = tax
self.names = names
self.class_number = class_number
self.queue = []
self.nr_dirs = 0
self.species = {}
self.args = args
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):
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 __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
# Context for journal handling
self.version = None
self.is_beta = False
self.mode = None
self.group = None
self.cmdr = None
self.captain = None # On a crew
self.role = None # Crew role - None, FireCon, FighterCon
self.body = None
self.system = None
self.station = None
self.coordinates = None
self.state = {} # Initialized in Fileheader
# Cmdr state shared with EDSM and plugins
self.state = {
'Cargo': defaultdict(int),
'Credits': None,
'Loan': None,
'Raw': defaultdict(int),
'Manufactured': defaultdict(int),
'Encoded': defaultdict(int),
'PaintJob': None,
'Rank': {
'Combat': None,
'Trade': None,
'Explore': None,
'Empire': None,
'Federation': None,
'CQC': None
},
'ShipID': None,
'ShipIdent': None,
'ShipName': None,
'ShipType': None,
'Missions': dict(),
}
def __init__(self, sender, relpath, onchange):
self.sender = sender
self.relpath = relpath
self.onchange = onchange
self.stop_requested = threading.Event()
self.stopped = threading.Event()
threading.Thread.__init__(self)
FileSystemEventHandler.__init__(self)
FsListener.__init__(self)
self.uid = str(uuid.uuid4())
def __init__(self, config, prompter: Prompter):
FileSystemEventHandler.__init__(self)
threading.Thread.__init__(self, daemon=True)
self.config = config
self.prompter = prompter
self.observer = Observer()
self.has_path = False
self.event_buffer = EventBuffer()
self._callback = None
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, 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 __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, 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):
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.seen = [] # interactions that we've already processed
self.interaction_queue = [
] # For communicating interactions back to main thread
def __init__(self, send_path, receive_uri, secret_key):
FileSystemEventHandler.__init__(self)
self.send_path = send_path.rstrip('/')
result = urlparse(receive_uri)
self.server = '%s://%s' % (result.scheme, result.netloc)
if 'Windows' in platform.system():
self.receive_path = result.path.strip('/')
else:
self.receive_path = result.path.rstrip('/')
self.secret_key = secret_key
def __init__(self, filename: str, callback: Callable[[], Any]):
if watchdog is None:
raise RuntimeError('watchdog module is not available')
MaybeFileSystemEventHandler.__init__(self)
BaseObserver.__init__(self, filename, callback)
# NOTE (@NiklasRosenstein): Using os.path.realpath() (which is used in BaseObserver()) is important
# because of https://github.com/gorakhargosh/watchdog/issues/821.
self._observer = Observer()
self._observer.schedule(self,
path=os.path.dirname(self.filename),
recursive=False)
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
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):
FileSystemEventHandler.__init__(self) # futureproofing - not need for current version of watchdog
self.root = None
self.logdir = self._logdir() # E:D client's default Logs directory, or None if not found
self.currentdir = None # The actual logdir that we're monitoring
self.logfile = None
self.observer = None
self.observed = None
self.thread = None
self.callbacks = { 'Jump': None, 'Dock': None }
self.last_event = None # for communicating the Jump event
def __init__(self, patterns, observer_class_name="Observer"):
"""Init the processor."""
FileSystemEventHandler.__init__(self)
self.input_dirs = []
for pattern in patterns:
self.input_dirs.append(os.path.dirname(pattern))
logger.debug("watching %s", str(os.path.dirname(pattern)))
self.patterns = patterns
self.new_file = Event()
self.observer = self.cases.get(observer_class_name, Observer)()
def __init__(self, options):
# print options
# Store the command line args
self.options = options
self.channel = Channel.objects.get(slug=self.options['channel_name'])
# Init ourselves some redis
pool = redis.ConnectionPool(host='localhost', port=6379, db=self.channel.redis_db)
r = redis.Redis(connection_pool=pool)
self.pipe = r.pipeline()
self.redis_index = 0
# If the overwrite flag is set, flush the redis db,
# set the channel line count to 0, and set the date
# context to the channel start date, else grab the latest
# date from the scores
if self.options['overwrite']:
r.flushdb()
self.channel.set_line_count(0)
self.date = self.channel.start_date
else:
self.date = self.channel.get_latest_date()
# Define the nick handling members
self.nicks = dict()
nick_regex_string = '[a-zA-Z0-9_-\{\}\^\`\|]+'
self.nick_regex_strings = [
'<(?P<nick>%s)>' % nick_regex_string,
'Action: (?P<nick>%s) ' % nick_regex_string,
'Nick change: (?P<nick>%s) ' % nick_regex_string,
'Topic changed on [#&][[a-zA-Z0-9]+ by (?P<nick>%s)\!' % nick_regex_string,
'%s kicked from [#&][[a-zA-Z0-9]+ by (?P<nick>%s)' % (nick_regex_string, nick_regex_string),
'(?P<nick>%s) \(.*\) [left|joined]' % nick_regex_string,
'[#&][[a-zA-Z0-9]+: mode change \'.*\' by (?P<nick>%s)\!' % nick_regex_string
]
#Grab a list of files in the target directory, sort and stick in a deque for optimized access (lists are slow)
self.dir = deque()
for f in sorted(filter(lambda x: self.options['filter_string'] in x, os.listdir(self.options['path']))):
self.dir.append('%s%s' % (self.options['path'], f))
# Open the first file in the queue
self.file = open(self.dir.popleft(), 'r')
# Set the initial file position
self.where = self.file.tell()
# Run the initial feed of the logs
self.ReadLog()
FileSystemEventHandler.__init__(self)
def __init__(self, cfg_path=None, sharing_path=None):
FileSystemEventHandler.__init__(self)
# Just Initialize variable the Daemon.start() do the other things
self.daemon_state = 'down' # TODO implement the daemon state (disconnected, connected, syncronizing, ready...)
self.running = 0
self.client_snapshot = {} # EXAMPLE {'<filepath1>: ['<timestamp>', '<md5>', '<filepath2>: ...}
self.local_dir_state = {} # EXAMPLE {'last_timestamp': '<timestamp>', 'global_md5': '<md5>'}
self.listener_socket = None
self.observer = None
self.cfg = self._load_cfg(cfg_path, sharing_path)
self.password = self._load_pass()
self._init_sharing_path(sharing_path)
self.conn_mng = ConnectionManager(self.cfg)
def __init__(self, monitor_dir, config, archive=False, initial_scan=False,
archive_suffix="_orig.pdf"):
FileSystemEventHandler.__init__(self)
self.monitor_dir = monitor_dir
self.archive_suffix = archive_suffix
self.archive = archive
if not config: config = {}
# Scan initial folder
if initial_scan:
self.scan_folder()
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, paper_filename, publish_url, paper_id):
FileSystemEventHandler.__init__(self) # super init
self.paper_filename = paper_filename
self.is_pdf = paper_filename.endswith('pdf')
self.publish_url = publish_url
self.paper_id = paper_id
self.reset_stats()
logging.info(
"Creating a GamificationHandler with paper: " + paper_filename +
" publish_url: " + publish_url +
" and paper id: " + paper_id
)
def __init__(self):
# Grab a list of files in the target directory, sort and stick in a deque for optimized access (lists are slow)
self.dir = deque()
for f in sorted(filter(lambda x: args.filter_string in x, os.listdir(args.path))):
self.dir.append('%s%s' % (args.path, f))
# Open the first file in the queue
self.file = open(self.dir.popleft(), 'r')
# Init ourselves some redis
self.r = redis.Redis(host='localhost', port=6379, db=args.db_index)
self.redis_index = 0
# Set the initial file position
self.where = self.file.tell()
# Run the initial feed of the logs
self.ReadLog()
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.logging_enabled = self._logging_enabled
self._restart_required = False
self.thread = None
self.last_event = None # for communicating the Jump event
if self.logdir:
# Set up a watchog observer. This is low overhead so is left running irrespective of whether monitoring is desired.
observer = Observer()
observer.daemon = True
observer.schedule(self, self.logdir)
observer.start()
atexit.register(observer.stop)
# Latest pre-existing logfile - e.g. if E:D is already running. Assumes logs sort alphabetically.
logfiles = sorted([x for x in listdir(self.logdir) if x.startswith('netLog.')])
self.logfile = logfiles and join(self.logdir, logfiles[-1]) or None
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
# Context for journal handling
self.version = None
self.is_beta = False
self.mode = None
self.cmdr = None
self.shipid = None
self.system = None
self.station = None
self.coordinates = None
self.ranks = None
self.credits = None
def __init__(self, paper_filename, publish_url, paper_id):
FileSystemEventHandler.__init__(self)
self.paper_filename = paper_filename
self.publish_url = publish_url
self.paper_id = paper_id
logging.info("Creating a GamificationHandler with paper: " +
paper_filename +
" publish_url: " +
publish_url +
" and paper id: " +
paper_id
)
self.stats = {}
self.words = {}
self.paragraphs = []
self.num_words = 0
self.total_word_len = 0
def __init__(self, wake_cb, only_cwd):
self.wake_cb = wake_cb
FileSystemEventHandler.__init__(self)
self.observer = Observer()
if only_cwd:
self.observePythonDirs(os.getcwd())
else:
for importer, name, ispkg in pkgutil.iter_modules():
if ispkg and '/lib/' not in importer.path:
self.observePythonDirs(importer.path)
try:
self.observer.start()
except OSError as e:
# clearer error for linux
if "inotify watch limit reached" in e:
print e
print "you should increase the inotify quotas"
print
print " sudo sysctl fs.inotify.max_user_watches=100000"
print " sudo sh -c 'echo fs.inotify.max_user_watches=100000>>/etc/sysctl.conf'"
sys.exit(1)
else:
raise
def __init__(self, dest_dir = "/", remove_base=None): FileSystemEventHandler.__init__(self) self.dest_dir = dest_dir self.remove_base = remove_base
def __init__(self, dbWorker):
FileSystemEventHandler.__init__(self)
self.__changedFiles = set()
self.__dbWorker = dbWorker
def __init__(self):
FileSystemEventHandler.__init__(self)
self.cache_context()
def __init__(self, scriptfile='', scriptargfile=''):
FileSystemEventHandler.__init__(self)
self.scriptfile = scriptfile
self.scriptargfile = scriptargfile
