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()