change API for drawing stuff

ability to provide kwargs to matplotlib
update zproc
add examples

Author: devxpy

Pipfile

@@ -6,10 +6,12 @@ name = "pypi"
 [packages]
 matplotlib = "*"
 zproc = "*"
-"pyqt5" = "*"
 
 [dev-packages]
 twine = "*"
 
 [requires]
 python_version = "3.6"
+
+[pipenv]
+allow_prereleases = true

Pipfile.lock

@@ -16,9 +16,9 @@ osc = Osc()
 
 
 @osc.signal
-def simple_random_signal(update):
+def simple_random_signal(state):
     while True:
-        update(random.random())
+        state.draw(random.random())
         sleep(0.1)
 
 
@@ -44,16 +44,16 @@ osc = Osc(nrows=2, ncols=3)
 
 
 @osc.signal
-def signal1(update):
+def signal1(state):
     while True:
-        update(random.random())
+        state.draw((random.random())
         sleep(0.1)
 
 
 @osc.signal
-def signal2(update):
+def signal2(state):
     while True:
-        update(random.random(), row=1, col=2)
+        state.draw(random.random(), row=1, col=2)
         sleep(0.1)
 
 
@@ -63,7 +63,7 @@ osc.start()
 
 <img src="https://i.imgur.com/PPC7z4m.png" height="300" />
 
-P.S. Don't worry about race conditions, `update()` is atomic. (See [zproc](https://github.com/pycampers/zproc))
+P.S. Don't worry about race conditions, `state.draw()` is atomic. (See [zproc](https://github.com/pycampers/zproc))
 
 ### Dynamic axis scale
 
@@ -82,11 +82,11 @@ osc = Osc(window_sec=10, intensity=1)
 
 
 @osc.signal
-def increasing_signal(update):
+def increasing_signal(state):
     delta = 1
 
     while True:
-        update(random.randint(-delta, delta))
+        state.draw(random.randint(-delta, delta))
         delta += 5
         sleep(0.01)
 
@@ -112,11 +112,11 @@ osc = Osc(normalize=True)
 
 
 @osc.signal
-def increasing_signal(update):
+def increasing_signal(state):
     delta = 1
 
     while True:
-        update(random.randint(-delta, delta))
+        state.draw(random.randint(-delta, delta))
         delta += 5
         sleep(0.01)
 

README.md

@@ -11,11 +11,11 @@
 
 
 @osc.signal
-def increasing_signal(update):
+def increasing_signal(state):
     delta = 1
 
     while True:
-        update(random.randint(-delta, delta))
+        state.draw(random.randint(-delta, delta))
         delta += 5
         sleep(0.01)
 

examples/increasing.py

@@ -11,11 +11,11 @@
 
 
 @osc.signal
-def increasing_signal(update):
+def increasing_signal(state):
     delta = 1
 
     while True:
-        update(random.randint(-delta, delta))
+        state.draw(random.randint(-delta, delta))
         delta += 5
         sleep(0.01)
 

examples/normalized.py

@@ -10,16 +10,16 @@
 
 
 @osc.signal
-def signal1(update):
+def signal1(state):
     while True:
-        update(random.random())
+        state.draw(random.random())
         sleep(0.1)
 
 
 @osc.signal
-def signal2(update):
+def signal2(state):
     while True:
-        update(random.random(), row=1, col=2)
+        state.draw(random.random(), row=1, col=2)
         sleep(0.1)
 
 

examples/parallel_signals.py

@@ -9,9 +9,9 @@
 
 
 @osc.signal
-def simple_random_signal(update):
+def simple_random_signal(state):
     while True:
-        update(random.random())
+        state.draw(random.random())
         sleep(0.1)
 
 

examples/simple_signal.py

@@ -0,0 +1,43 @@
+import time
+
+import psutil
+
+from oscilloscope import Osc
+
+osc = Osc(nrows=2, ncols=2)
+
+
+@osc.signal
+def cpu_usage(state):
+    # This will adjust graph to the max value, 100 and set the labels.
+    state.draw(100, col=0, ylabel="core0")
+    state.draw(100, col=1, ylabel="core1")
+
+    while True:
+        time.sleep(0.25)
+        for i, cpu in enumerate(psutil.cpu_percent(percpu=True)):
+            state.draw(cpu, col=i)
+
+
+@osc.signal
+def ram_usage(state):
+    # This will adjust graph to the max value, 100 and set the labels.
+    state.draw(100, row=1, ylabel="ram")
+
+    while True:
+        time.sleep(0.25)
+        meminfo = psutil.virtual_memory()
+        state.draw(meminfo.available / meminfo.total * 100, row=1)
+
+
+@osc.signal
+def combined_cpu(state):
+    # This will adjust graph to the max value, 100 and set the labels.
+    state.draw(100, row=1, col=1, ylabel="total cpu")
+
+    while True:
+        time.sleep(0.25)
+        state.draw(psutil.cpu_percent(), row=1, col=1)
+
+
+osc.start()

examples/sys_monitor.py

@@ -1,131 +1,178 @@
-import matplotlib
-
-matplotlib.use("Qt5Agg")
-
 from functools import wraps
-from typing import Union
+from typing import Union, Callable
 
 import matplotlib.animation as animation
 import matplotlib.pyplot as plt
 import numpy as np
 import zproc
 from matplotlib.lines import Line2D
 
-ctx = zproc.Context()
+zproc_ctx = zproc.Context()
+ZPROC_INTERNAL_NAMESPACE = "oscilloscope"
 
 
 class Normalizer:
-    def __init__(self):
-        self.bounds = [0, 0]
-        self.norm_factor = 0
+    def __init__(self, output_range: tuple = (0, 100)):
+        self._input_min = 0
+        self._input_max = 0
+
+        self._output_min, self._output_max = output_range
+        self._output_diff = self._output_max - self._output_min
 
-    def refresh_norm_factor(self):
-        self.norm_factor = 1 / (self.bounds[1] - self.bounds[0]) * 100
+        self._norm_factor = 0
 
-    def adjust_norm_factor(self, val):
-        if val < self.bounds[0]:
-            self.bounds[0] = val
-            self.refresh_norm_factor()
-        elif val > self.bounds[1]:
-            self.bounds[1] = val
-            self.refresh_norm_factor()
+    def _refresh_norm_factor(self):
+        self._norm_factor = 1 / (self._input_max - self._input_min) * self._output_diff
 
-    def normalize(self, val):
-        self.adjust_norm_factor(val)
+    def _refresh_bounds(self, input_value):
+        if input_value < self._input_min:
+            self._input_min = input_value
+            self._refresh_norm_factor()
+        elif input_value > self._input_max:
+            self._input_max = input_value
+            self._refresh_norm_factor()
 
-        return (val - self.bounds[0]) * self.norm_factor
+    def normalize(self, input_value):
+        self._refresh_bounds(input_value)
+        return (input_value - self._input_min) * self._norm_factor + self._output_min
+
+
+def shift(ax, x):
+    return np.delete(np.append(ax, x), 0)
 
 
 class AnimationScope:
     def __init__(
         self,
-        ax,
+        ax: plt.Axes,
         window_sec,
         frame_interval_sec,
-        xlabel,
-        ylabel,
         row_index,
         col_index,
         intensity,
+        padding_percent,
     ):
         self.row_index = row_index
         self.col_index = col_index
         self.ax = ax
+        self.padding_percent = padding_percent
 
-        self.bounds = [0, 0]
+        self.frame_interval_sec = frame_interval_sec
+        self.num_frames = int(window_sec / self.frame_interval_sec)
 
-        num_frames = int(window_sec / frame_interval_sec)
-        self.time_axis = np.linspace(-window_sec, 0, num_frames)
-        self.amplitude_axis = np.zeros([1, num_frames])
+        self.y_values = np.zeros([1, self.num_frames])
+        self.x_values = np.linspace(-window_sec, 0, self.num_frames)
 
-        self.line = Line2D(self.time_axis, self.amplitude_axis, linewidth=intensity)
+        self.line = Line2D(self.x_values, self.y_values, linewidth=intensity)
         self.ax.add_line(self.line)
-        self.ax.set(xlim=(-window_sec, 0), xlabel=xlabel, ylabel=ylabel)
+        self.ax.set_xlim(-window_sec, 0)
+
+        self.y_limits = np.array([0, np.finfo(np.float).eps])
+        self.ax.set_ylim(self.y_limits[0], self.y_limits[1])
+
+        self._internal_state = zproc.State(
+            zproc_ctx.server_address, namespace=ZPROC_INTERNAL_NAMESPACE
+        )
+
+    def _adjust_ylim(self):
+        padding = self.padding_percent * (self.y_limits[1] - self.y_limits[0]) / 100
+        self.ax.set_ylim(self.y_limits[0] - padding, self.y_limits[1] + padding)
+
+    def _adjust_ylim_if_req(self, amplitude):
+        if amplitude < self.y_limits[0]:
+            self.y_limits[0] = amplitude
+            self._adjust_ylim()
+        elif amplitude > self.y_limits[1]:
+            self.y_limits[1] = amplitude
+            self._adjust_ylim()
+
+    def draw(self, _):
+        try:
+            amplitude, kwargs = self._internal_state[(self.row_index, self.col_index)]
+        except KeyError:
+            pass
+        else:
+            # set the labels
+            self.ax.set(**kwargs)
+
+            try:
+                size = np.ceil(self.num_frames / len(amplitude))
+                self.y_values = np.resize(
+                    np.repeat(np.array([amplitude]), size, axis=1), [1, self.num_frames]
+                )
 
-    def refresh_ylim(self):
-        self.ax.set_ylim(self.bounds)
+                self._adjust_ylim_if_req(np.min(self.y_values))
+                self._adjust_ylim_if_req(np.max(self.y_values))
+            except TypeError:
+                self.y_values = shift(self.y_values, amplitude)
+                self._adjust_ylim_if_req(amplitude)
 
-    def adjust_ylim(self, amplitude):
-        if amplitude < self.bounds[0]:
-            self.bounds[0] = amplitude
-            self.refresh_ylim()
-        elif amplitude > self.bounds[1]:
-            self.bounds[1] = amplitude
-            self.refresh_ylim()
+            # update line
+            self.line.set_data(self.x_values, self.y_values)
+        return [self.line]
 
-    def draw(self, n):
-        amplitude = ctx.state.get((self.row_index, self.col_index), 0)
 
-        # make adjustments to the ylim if required
-        self.adjust_ylim(amplitude)
+def _signal_process(state: zproc.State, fn: Callable, normalize: bool, *args, **kwargs):
+    if normalize:
+        normalizer = Normalizer()
 
-        # Add new amplitude to end
-        self.amplitude_axis = np.append(self.amplitude_axis, amplitude)
+        def _normalize(val):
+            return normalizer.normalize(val)
 
-        # remove old amplitude from start
-        self.amplitude_axis = np.delete(self.amplitude_axis, 0)
+    else:
 
-        # update line
-        self.line.set_data(self.time_axis, self.amplitude_axis)
+        def _normalize(val):
+            return val
 
-        return (self.line,)
+    _internal_state = zproc.State(
+        state.server_address, namespace=ZPROC_INTERNAL_NAMESPACE
+    )
+
+    def draw(amplitude, *, row=0, col=0, **kwargs):
+        amplitude = _normalize(amplitude)
+        _internal_state[(row, col)] = amplitude, kwargs
+
+    state.draw = draw
+    fn(state, *args, **kwargs)
 
 
 class Osc:
     def __init__(
         self,
         *,
-        fps: Union[float, int] = 60,
+        fps: Union[float, int] = 24,
         window_sec: Union[float, int] = 5,
         intensity: Union[float, int] = 2.5,
         normalize: bool = False,
         xlabel: str = "Time (sec)",
         ylabel: str = "Amplitude",
         nrows: int = 1,
         ncols: int = 1,
+        padding_percent: Union[float, int] = 0,
     ):
         frame_interval_sec = 1 / fps
 
         self.nrows = nrows
         self.ncols = ncols
         self.normalize = normalize
+        self.xlabel = xlabel
+        self.ylabel = ylabel
 
-        self.scopes = []
+        self.anim_scopes = {}
         self.gc_protect = []
 
         fig, axes = plt.subplots(self.nrows, self.ncols, squeeze=False)
 
         for row_index, row_axes in enumerate(axes):
             for col_index, ax in enumerate(row_axes):
                 scope = AnimationScope(
-                    ax,
-                    window_sec,
-                    frame_interval_sec,
-                    xlabel,
-                    ylabel,
-                    row_index,
-                    col_index,
-                    intensity,
+                    ax=ax,
+                    window_sec=window_sec,
+                    frame_interval_sec=frame_interval_sec,
+                    row_index=row_index,
+                    col_index=col_index,
+                    intensity=intensity,
+                    padding_percent=padding_percent,
                 )
 
                 self.gc_protect.append(
@@ -134,48 +181,27 @@ def __init__(
                     )
                 )
 
-                self.scopes.append(scope)
-
-    def signal(self, fn):
-        @wraps(fn)
-        def _singal(state, nrows, ncols, normalize):
-            if normalize:
-                normalizer = Normalizer()
-
-                def update_fn(amplitude, row=0, col=0):
-                    if not 0 <= row < nrows:
-                        raise ValueError(
-                            f'"row" must be one of {list(range(0, nrows))}'
-                        )
-                    if not 0 <= col < ncols:
-                        raise ValueError(
-                            f'"col" must be one of {list(range(0, ncols))}'
-                        )
-
-                    state[(row, col)] = normalizer.normalize(amplitude)
+                self.anim_scopes[(row_index, col_index)] = scope
 
-            else:
+    def signal(self, fn=None, **process_kwargs):
+        if fn is None:
 
-                def update_fn(amplitude, row=0, col=0):
-                    if not 0 <= row < nrows:
-                        raise ValueError(
-                            f'"row" must be one of {list(range(0, nrows))}'
-                        )
-                    if not 0 <= col < ncols:
-                        raise ValueError(
-                            f'"col" must be one of {list(range(0, ncols))}'
-                        )
+            @wraps(fn)
+            def wrapper(fn):
+                return self.signal(fn, **process_kwargs)
 
-                    state[(row, col)] = amplitude
+            return wrapper
 
-            fn(update_fn)
+        process_kwargs["start"] = False
+        process_kwargs["args"] = (fn, self.normalize, *process_kwargs.get("args", ()))
 
-        return ctx.process(_singal, args=(self.nrows, self.ncols, self.normalize))
+        return zproc_ctx.process(_signal_process, **process_kwargs)
 
     def start(self):
+        zproc_ctx.start_all()
         plt.show()
+        zproc_ctx.wait_all()
 
     def stop(self):
-        ctx.stop_all()
+        zproc_ctx.stop_all()
         plt.close()
-        print(ctx.process_list)

oscilloscope.py

@@ -18,10 +18,10 @@
 EMAIL = "devxpy@gmail.com"
 AUTHOR = "Dev Aggarwal"
 REQUIRES_PYTHON = ">=3.6.0"
-VERSION = "0.0.2"
+VERSION = "0.0.3"
 
 # What packages are required for this module to be executed?
-REQUIRED = ["matplotlib", "zproc", "pyqt5"]
+REQUIRED = ["matplotlib", "zproc"]
 
 # What packages are optional?
 EXTRAS = {}