def _pull(self):
self._check_dependencies()
np = load_optional_module('numpy', self.EXTRA)
pyaudio = load_optional_module('pyaudio', self.EXTRA)
pa = pyaudio.PyAudio()
stream = pa.open(format=pyaudio.paInt16,
input_device_index=self.device_index,
channels=1,
rate=self.RATE,
input=True,
frames_per_buffer=self.CHUNK_SIZE)
try:
buffers = [None
for _ in self.wav_files] # Init buffer foreach wav_file
while not self.stopped:
data = np.fromstring(stream.read(
self.CHUNK_SIZE,
exception_on_overflow=not self.ignore_overflow),
dtype=np.int16)
for i, buffer in enumerate(buffers):
config = self.wav_files[i]
buffer = self._process_single(buffer, data, np, config)
buffers[i] = buffer
finally:
stream.close()
pa.terminate()
# Emit any pending cooldown events
for config in self.wav_files:
config.notify.execute_now()
def _push(self, target_file_name, payload): # pylint: disable=arguments-differ
target_file_name = self._sanitze_target_file_name(target_file_name)
# Upload file or stream to dropbox
dropbox = load_optional_module('dropbox', self.EXTRA)
dbx = dropbox.Dropbox(self.api_key, timeout=None)
fcontent = get_bytes(payload) # Might be a file or a stream
self.logger.info("Uploading file to dropbox '%s'", target_file_name)
metadata = dbx.files_upload(
fcontent,
target_file_name,
mode=dropbox.files.WriteMode("overwrite")
)
res = dict(
name=metadata.name,
id=metadata.id,
content_hash=metadata.content_hash,
size=metadata.size,
path=metadata.path_display,
shared_link=None,
raw_link=None
)
if self.create_shared_link:
# create a shared link
shared_link = dbx.sharing_create_shared_link(target_file_name)
res['shared_link'] = shared_link.url
res['raw_link'] = self._make_raw_file_url(shared_link.url)
return res
def _setup_handler(self, authorizer):
handlers = load_optional_module('pyftpdlib.handlers', self.EXTRA)
handler = handlers.FTPHandler
handler.authorizer = authorizer
handler.banner = 'Welcome to pnp embedded ftp server'
self._register_callbacks(handler)
return handler
def _setup_server(self, handler):
self.logger.debug("Setting up server on 127.0.0.1:%s", str(self.port))
servers = load_optional_module('pyftpdlib.servers', self.EXTRA)
address = ('', self.port)
server = servers.ThreadedFTPServer(address, handler)
server.max_cons = self.max_cons
server.max_cons_per_ip = self.max_cons_ip
return server
def _init(self):
if self._poller:
# We already got a miflora poller -> abort
return
mfp = load_optional_module('miflora.miflora_poller', self.EXTRA)
self._poller = mfp.MiFloraPoller(mac=self.mac,
adapter=self.adapter,
backend=self._find_backend())
self.logger.debug("Initialization for %s finished", self.mac)
def _poll(self) -> Payload:
speedtest = load_optional_module('speedtest', self.EXTRA)
client = speedtest.Speedtest()
client.get_servers()
client.get_best_server()
client.download(threads=None)
client.upload(threads=None)
client.results.share()
res = client.results.dict()
return glom(res, self.OUTPUT_SPEC)
def _configure(self):
# Do not break the complete module, when extra_packages are not present
self.face_recognition = load_optional_module('face_recognition',
self.EXTRA)
# If both are set known_faces is the default
if self.known_faces:
self.known_names, self.known_encodings = self._load_from_mapping(
self.known_faces)
else:
self.known_names, self.known_encodings = self._load_from_directory(
self.known_faces_dir)
def _get_sensor_readings(self):
assert self._poller
mfp = load_optional_module('miflora.miflora_poller', self.EXTRA)
reading_params = [
mfp.MI_CONDUCTIVITY, mfp.MI_LIGHT, mfp.MI_MOISTURE,
mfp.MI_TEMPERATURE, mfp.MI_BATTERY
]
res = {
para: self._poller.parameter_value(para)
for para in reading_params
}
return {**res, **{'firmware': self._poller.firmware_version()}}
def _setup_auth(self, ftp_directory):
auth = load_optional_module('pyftpdlib.authorizers', self.EXTRA)
authorizer = auth.DummyAuthorizer()
if self.user:
self.logger.debug(
"Setting up authorization: %s:%s @ %s",
self.user, '*' * len(self.password), ftp_directory
)
authorizer.add_user(self.user, self.password, ftp_directory, perm='elradfmw')
else:
self.logger.debug("Setting up anonymous access @ %s", ftp_directory)
authorizer.add_anonymous(ftp_directory, perm='elradfmw')
return authorizer
def _setup(self):
if self.fritz_box:
# Nothing to do
return
fritz_hosts = load_optional_module('fritzconnection.lib.fritzhosts',
self.EXTRA)
try:
self.fritz_box = fritz_hosts.FritzHosts(address=self.host,
user=self.user,
password=self.password)
if not self.fritz_box.modelname:
raise ValueError()
except Exception: # pylint: disable=broad-except
self.logger.exception(
"Cannot connect to the Fritz!Box @ %s. Please review the configuration",
self.host)
self.fritz_box = None
self.logger.info("Connected to the Fritz!Box @ %s", self.host)
def _check_dependencies(self):
load_optional_module('numpy', self.EXTRA)
load_optional_module('pyaudio', self.EXTRA)
load_optional_module('scipy', self.EXTRA)
load_optional_module('scipy.io.wavfile', self.EXTRA)
load_optional_module('scipy.stats.stats', self.EXTRA)
def _pull(self):
wdog = load_optional_module('watchdog.observers', self.EXTRA)
wev = load_optional_module('watchdog.events', self.EXTRA)
that = self
class _EventHandler(wev.PatternMatchingEventHandler):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.dispatcher = {}
@staticmethod
def _read_file_from_event(event):
if (event.event_type != that.EVENT_TYPE_DELETED
and not getattr(event, 'is_directory', False)):
file_name = (getattr(event, 'dest_path', None)
or getattr(event, 'src_path', None))
if file_name is not None:
return load_file(file_name, that.mode, that.base64)
return None
def stop_dispatcher(self):
"""Stops any pending debounces when the plugin is going to stop."""
# We cannot alter the dictionary during iteration - so we have to get all relevant
# debounces beforehand...
candidates = [
debounce for _, debounce in self.dispatcher.items()
]
# ... and then loop it over outside the iterator context
for debounce in candidates:
debounce.execute_now()
def _deferred_notify(self, modified_file, payload):
# Let's remove the dispatcher instance - it is done
self.dispatcher.pop(modified_file, None)
# trigger the actual notification event
that.notify(payload)
def _notify(self, event, payload):
if event.event_type == that.EVENT_TYPE_MODIFIED:
# There might be multiple flushes of a file before it is completely written to
# disk. Each flush will raise a modified event...
# Let's wait for more modified events...
if that.defer_modified <= 0:
that.notify(payload)
else:
modified_file = payload['source']
defer_fun = self.dispatcher.get(modified_file, None)
if defer_fun is None:
defer_fun = Debounce(self._deferred_notify,
that.defer_modified)
self.dispatcher[modified_file] = defer_fun
defer_fun(modified_file, payload)
that.logger.debug(
"Event of modified_file '%s' is deferred for %s",
modified_file, that.defer_modified)
else:
defer_fun = self.dispatcher.get(payload['source'], None)
# There might be some deferred modified event... Lets check and send it to keep
# the correct sequence. Assuming the file is closed and finished by now...
if defer_fun is not None:
defer_fun.execute_now()
that.notify(payload)
def on_any_event(self, event):
"""Callback for watchdog."""
if that.events is None or event.event_type in that.events:
payload = {
'operation': event.event_type,
'is_directory': getattr(event, 'is_directory', False),
'source': getattr(event, 'src_path', None),
'destination': getattr(event, 'dest_path', None)
}
that.logger.info("Got '%s'", payload)
if that.load_file:
file_envelope = self._read_file_from_event(event)
if file_envelope is not None:
payload['file'] = file_envelope
self._notify(event, payload)
observer = wdog.Observer()
handler = _EventHandler(patterns=self.patterns,
ignore_patterns=self.ignore_patterns,
ignore_directories=self.ignore_directories,
case_sensitive=self.case_sensitive)
observer.schedule(handler, self.path, recursive=self.recursive)
observer.start()
while not self.stopped:
time.sleep(1)
observer.stop()
handler.stop_dispatcher()
observer.join()