Das deutsche Python-Forum

Code: Alles auswählen

class MPDProxy:
    def __init__(self, host="mpdhost", port=6600):
        self.client = mpd.MPDClient()
        self.host = host
        self.port = port
        # number of (reconnects)
        self.reconnects = 0
        self.isConnected = False
        self.connect(host, port)

    # because we do not know what function will be called, we use __getattr__
    # eg. mpd.idle() ->  __getattr__ self: <mpd_proxy.MPDProxy object at 0x7f5fa7265b70>, name: idle
    def __getattr__(self, name):
        #if self.isConnected: #debug not shure if neccesary
        return self._call_with_reconnect(getattr(self.client, name))

    def connect(self, host, port):
        what = "connecting" if self.reconnects == 0 else "reconnecting"
        logging.info(f"{self.reconnects}:{what} ...")
        self.reconnects bananapi+=1
        self.client.connect(host, port)

        #if self.client.mpd_version:
        if self.client:
            self.isConnected = True
            logging.info(f"MPDPROXY connected to {host}:{port}")
        else:
            self.isConnected = False
            logging.info(f"MPDPROXY not connected!")

    def _call_with_reconnect(self, func):
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except mpd.ConnectionError as e:
                self.isConnected = False
                self.connect(self.host, self.port, )
                logging.error(f"{e}")
                return func(*args, **kwargs)
            except OSError as e:
                self.isConnected = False
                logging.error(f"{e}")
                self.client.disconnect()
                self.client = mpd.MPDClient()
                pass
            except Exception as e:
                logging.error(f"{e}")
                pass
        return wrapper

Code: Alles auswählen

import time, os
from threading import Thread, Event
# logging
import logging
from util import *

from mpd_proxy import MPDProxy
import tkinter as tk

class Fetcher(Thread):
    def __init__(self, playerApp = None):
        Thread.__init__(self)
        self.stopped = Event()
        self.playerApp = playerApp
        # to get/set config user self.playerApp handle
        self.client = self.playerApp.getClient()
        self.currentsong = None
        self.config = playerApp.appconfig
        self.fetcherIntervall = self.config.get("fetcherIntervall")

    def run(self):
        # https://stackoverflow.com/questions/12435211/threading-timer-repeat-function-every-n-seconds#12435256
        name = self.__class__.__name__
        while not self.stopped.wait(int(self.fetcherIntervall)):
            logging.debug(f"THREAD is running {self.client}/{self.fetcherIntervall}....")

            self.client = self.playerApp.getClient()
            if not self.client: logging.error("No Client (None) ")
            if self.client:
                logging.debug("Fetching Data ...")
                self.currentsong = self.client.currentsong()
                logging.debug(self.currentsong)

    def stop(self):
        name = self.__class__.__name__
        logging.info(f"{name}: Thread stops ...")
        self.stopped.set()

Code: Alles auswählen

self.after(seconds, self.update)