!!! Changed plugin initialization !!! Please view documentation for more information

added telegram admin preview modes
added example in documentation
added script functions
added script support in plugins
added full access to RTOC-data for plugins
added telegram_send_plot for plugins

Author: Sebastian

RTOC/LoggerPlugin.py

@@ -1,4 +1,4 @@
-# LoggerPlugin v2.6
+# LoggerPlugin v2.7
 import traceback
 import time
 import sys
@@ -10,31 +10,36 @@
 
 try:
     from . import jsonsocket
+    from .RTLogger import scriptLibrary as rtoc
 except (SystemError, ImportError):
     import jsonsocket
+    import RTLogger.scriptLibrary as rtoc
 
 lock = Lock()
 
 
 class LoggerPlugin:
     """
-
-
     Args:
-        stream (method): The callback-method for the stream-method
-        plot (method): The callback-method for the plot-method
-        event (method): The callback-method for the event-method
-        telegramBot (object): Object for telegram-methods
-
+        logger (RTLogger): The parent RTLogger-instance
     """
-    def __init__(self, stream=None, plot=None, event=None, telegramBot=None, *args, **kwargs):
+    def __init__(self, logger=None, *args, **kwargs):
         # Plugin setup
         # self.setDeviceName()
         self._devicename = "noDevice"
-        self._cb = stream
-        self._ev = event
-        self._plt = plot
-        self._bot = telegramBot
+        self.rtoc = rtoc
+        if logger is not None:
+            self.logger = logger
+            self._cb = logger.database.addDataCallback
+            self._ev = logger.database.addNewEvent
+            self._plt = logger.database.plot
+            self._bot = logger.telegramBot
+        else:
+            self._logger = None
+            self._cb = None
+            self._ev = None
+            self._plt = None
+            self._bot = None
         self._sock = None
         self._tcppassword = ''
         self._tcpport = 5050
@@ -532,7 +537,7 @@ def __updateT(self, func):
 
     def telegram_send_message(self, text, priority=0, permission='write'):
         """
-        Sends a message to all clients (or only admins).
+        Sends a message to all clients with given permission and higher permission.
 
         Args:
             text (str): Text to be send to the clients.
@@ -546,7 +551,7 @@ def telegram_send_message(self, text, priority=0, permission='write'):
 
     def telegram_send_photo(self, path, priority=0, permission='write'):
         """
-        Sends the picture at a given path to all clients (or only admins).
+        Sends the picture at a given path to all clients with given permission and higher permission.
 
         Args:
             path (str): Path to the picture to send.
@@ -560,7 +565,7 @@ def telegram_send_photo(self, path, priority=0, permission='write'):
 
     def telegram_send_document(self, path, priority=0, permission='write'):
         """
-        Sends any document at a given path to all clients (or only admins).
+        Sends any document at a given path to all clients with given permission and higher permission.
 
         Args:
             path (str): Path to the file to send.
@@ -572,6 +577,23 @@ def telegram_send_document(self, path, priority=0, permission='write'):
         else:
             logging.warning('TelegramBot is not enabled or wrong configured! Can not send file "{}"'.format(path))
 
+    def telegram_send_plot(self, signals={}, title='', text='', events=[], dpi=300, priority=0, permission='write'):
+        """
+        Sends any document at a given path to all clients with given permission and higher permission.
+
+        Args:
+            signals (dict): Contains multiple sets of x-y data, e.g. ``{'signal1':[1,2,3,4,5],[4,3,6,5,7]}``
+            title (str): The title displayed above the graph.
+            text (str): The plot-description text
+            events (list): A list containing pseudo-events (text+vertical-line), e.g. ``[[10, 'Hello world at x=10']]``
+            dpi (int): Resolution of plot.
+            priority (int): Priority to decide, which allow each client to disable notifications (0: Information, 1: Warning, 2: Error)
+            permission (str): Choose user-permission (blocked, read, write, admin)
+        """
+        if self._bot is not None:
+            self._bot.send_plot(signals, title, text, events, dpi, priority, permission)
+        else:
+            logging.warning('TelegramBot is not enabled or wrong configured! Can not send plot')
 
 
 class _perpetualTimer():

RTOC/RTLogger/DeviceFunctions.py

@@ -86,7 +86,7 @@ def startPlugin(self, name, remote=True):
                 # if callback is None:
                 self.pluginObjects[
                     name] = importlib.import_module(
-                    fullname).Plugin(stream=self.database.addDataCallback, plot=self.database.plot, event=self.database.addNewEvent, telegramBot=self.telegramBot)
+                    fullname).Plugin(logger=self)
                 # else:
                 #     self.pluginObjects[name] = importlib.import_module(
                 #         fullname).Plugin(callback, self.addNewEvent)

RTOC/RTLogger/NetworkFunctions.py

@@ -343,12 +343,12 @@ def getPluginDict(self):
             dict[name]['parameters'] = []
             dict[name]['status'] = False
             for fun in self.pluginFunctions.keys():
-                hiddenFuncs = ["loadGUI", "updateT", "stream", "plot", "event", "createTCPClient", "sendTCP", "close", "cancel", "start", "setSamplerate","setDeviceName",'setPerpetualTimer','setInterval','getDir', 'telegram_send_message', 'telegram_send_photo', 'telegram_send_document']
+                hiddenFuncs = ["loadGUI", "updateT", "stream", "plot", "event", "createTCPClient", "sendTCP", "close", "cancel", "start", "setSamplerate","setDeviceName",'setPerpetualTimer','setInterval','getDir', 'telegram_send_message', 'telegram_send_photo', 'telegram_send_document', 'telegram_send_plot']
 
                 if fun.startswith(name+".") and fun not in [name+'.'+i for i in hiddenFuncs]:
                     dict[name]['functions'].append(fun.replace(name+".", ''))
             for fun in self.pluginParameters.keys():
-                hiddenParams = ["run", "smallGUI", 'widget', 'samplerate','lockPerpetialTimer']
+                hiddenParams = ["run", "smallGUI", 'widget', 'samplerate','lockPerpetialTimer','logger']
 
                 if fun.startswith(name+".") and fun not in [name+'.'+i for i in hiddenParams]:
                     value = self.getPluginParameter(name, "get", fun.replace(name+".", ''))

RTOC/RTLogger/ScriptFunctions.py

@@ -17,6 +17,7 @@ def generateCode(self, s, condition=False):
         s = self.replacePluginMethods(s)
         s = self.replaceSignalNames(s)
         s = self.replaceLoggerFunctions(s)
+        s = self.replaceTelegramFunctions(s)
         s, init = self.replaceGlobalVariables(s)
         s = s.replace('global.', 'self.')
         s = self.replaceLibraryFunctions(s)
@@ -91,6 +92,15 @@ def replaceLoggerFunctions(self, s):
         s = s.replace("sendTCP(", "self._sendTCP(")
         return s
 
+    def replaceTelegramFunctions(self, s):
+        s = s.replace("telegram.send_photo(", "self.telegramBot.send_photo(")
+
+        s = s.replace("telegram.send_document(", "self.telegramBot.send_document(")
+        s = s.replace("telegram.send_plot(", "self.telegramBot.send_plot(")
+
+        s = s.replace("telegram.send_message_to_all(", "self.telegramBot.send_message_to_all(")
+        return s
+
     def replaceGlobalVariables(self, s):
         globals = []
         for item in s.split("\n"):

RTOC/RTLogger/scriptLibrary.py

@@ -13,6 +13,12 @@
 log.basicConfig(level=log.INFO)
 logging = log.getLogger(__name__)
 
+try:
+    from statsmodels.tsa.ar_model import AR
+    from sklearn.metrics import mean_squared_error
+except (ImportError, SystemError):
+    AR = None
+    logging.info('statsmodels and sklearn is not installed. Cannot use "rtoc.estimate".')
 
 def lsfit(self, x, y, func="linear", x0=None, n=None):
     """
@@ -75,7 +81,7 @@ def resample(self, x, y, n=None):
         x (list): x-values (a linspace)
         y (list): Interpolated y-values
     """
-    if n is None:
+    if n is None and self is not None:
         n = self.config['global']['recordLength']
     if len(x) == len(y):
         x2 = np.linspace(x[0], x[-1], n)
@@ -290,3 +296,128 @@ def norm(x, y, max=1, min=0, oldMin=None, oldMax=None):
     y = (y-oldMin)/oldMax
     y = y*max+min
     return x, y
+
+def predict(coef, history):
+    """
+    Make a prediction give regression coefficients and lag obs
+    """
+    yhat = coef[0]
+    for i in range(1, len(coef)):
+        yhat += coef[i] * history[-i]
+    return yhat
+
+def estimate(x,y, n):
+    """
+    Estimate n values in future for a signal using ARMA. You need to install the following python packages with pip3: ``pip3 install statsmodels scikit-learn scikit-metrics patsy``
+
+    Args:
+        x (list): List of x-values
+        y (list): List of y-values
+        n (int): Number of values to be estimated
+
+    Returns:
+        x (list): List of estimated x-values
+        y (list): List of estimated y-values
+    """
+    if AR is None:
+        return
+
+    x, y = resample(None, x, y, n=len(x))
+    samplerate = 1/(x[1]-x[0])
+
+    #train = np.diff(y)
+    train = np.array(y)
+    test = np.linspace(x[-1]+1/samplerate, x[-1]+(1/samplerate)*n, n)
+    # size = int(len(data) * 0.66)
+    # train, test = data[0:size], data[size:]
+    # train autoregression
+    model = AR(train)
+    model_fit = model.fit(maxlag=6, disp=False)
+    window = model_fit.k_ar
+    coef = model_fit.params
+    # walk forward over time steps in test
+    history = [train[i] for i in range(len(train))]
+    predictions = list()
+    for t in range(len(test)):
+        yhat = predict(coef, history)
+        predictions.append(yhat)
+        history.append(yhat)
+    error = mean_squared_error(test, predictions)
+    print('Test MSE: %.3f' % error)
+
+    return test, predictions
+
+def correlate(x1,y1,x2,y2, mode='valid'):
+    """
+    Crosscorrelate two signals using numpy.correlate
+
+    Args:
+        x1 (list): List of x-values of signal 1
+        y1 (list): List of y-values of signal 1
+        x1 (list): List of x-values of signal 2
+        y1 (list): List of y-values of signal 2
+        mode: {'valid', 'same', 'full') Refer to the convolve docstring. Note that the default is ‘valid’, unlike convolve, which uses ‘full’.
+
+    Returns:
+        x (list): List of x-values
+        y (list): List of correlated y-values
+    """
+    maxL = max([len(y1), len(y2)])
+    x,ys = combine(None, [[x1,y1],[x2,y2]], n=maxL)
+    y = np.correlate(ys[0], ys[1], mode)
+
+    return x, y
+
+def forwardEuler(x,y, f, U_0, samplerate, T):
+    dt = 1/samplerate
+    N_t = int(round(float(T)/dt))
+    u = np.zeros(N_t+1)
+    t = np.linspace(0, N_t*dt, len(u))
+    u[0] = U_0
+    for n in range(N_t):
+        u[n+1] = u[n] + dt*f(u[n], t[n])
+    return t,u
+
+def CCN():
+    """
+    https://machinelearningmastery.com/how-to-get-started-with-deep-learning-for-time-series-forecasting-7-day-mini-course/
+
+    https://machinelearningmastery.com/time-series-prediction-lstm-recurrent-neural-networks-python-keras/
+
+    
+    Estimate n values in future for a signal using Convolutional Neural Network model. You need to install the following python packages with pip3: ``pip3 install tensorflow keras``
+
+    Args:
+        x (list): List of x-values
+        y (list): List of y-values
+        n (int): Number of values to be estimated
+
+    Returns:
+        x (list): List of estimated x-values
+        y (list): List of estimated y-values
+    """
+    from keras.models import Sequential
+    from keras.layers import Dense
+    from keras.layers import Flatten
+    from keras.layers.convolutional import Conv1D
+    from keras.layers.convolutional import MaxPooling1D
+    # define dataset
+    X = np.array([[10, 20, 30], [20, 30, 40], [30, 40, 50], [40, 50, 60]])
+    y = np.array([40, 50, 60, 70])
+    # reshape from [samples, timesteps] into [samples, timesteps, features]
+    X = X.reshape((X.shape[0], X.shape[1], 1))
+    # define model
+    model = Sequential()
+    model.add(Conv1D(filters=64, kernel_size=2, activation='relu', input_shape=(3, 1)))
+    model.add(MaxPooling1D(pool_size=2))
+    model.add(Flatten())
+    model.add(Dense(50, activation='relu'))
+    model.add(Dense(1))
+    model.compile(optimizer='adam', loss='mse')
+    # fit model
+    model.fit(X, y, epochs=1000, verbose=0)
+    # demonstrate prediction
+    x_input = np.array([50, 60, 70])
+    x_input = x_input.reshape((1, 3, 1))
+    yhat = model.predict(x_input, verbose=0)
+    print(yhat)