Merge branch 'v2.1.0-dev' into stage-calibration

openflexure_microscope/api/app.py

@@ -1,4 +1,8 @@
 #!/usr/bin/env python
+from gevent import monkey
+
+# Patch most system modules. Leave threads untouched so we can still use them normally if needed.
+monkey.patch_all(thread=False)
 
 import time
 import atexit
@@ -60,6 +64,7 @@ app, labthing = create_app(
     prefix="/api/v2",
     title=f"OpenFlexure Microscope {api_microscope.name}",
     description="Test LabThing-based API for OpenFlexure Microscope",
+    types=["org.openflexure.microscope"],
     version=pkg_resources.get_distribution("openflexure_microscope").version,
     flask_kwargs={"static_url_path": ""},
 )
@@ -167,5 +172,9 @@ def cleanup():
 
 atexit.register(cleanup)
 
+# Start the app
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port="5000", threaded=True, debug=True, use_reloader=False)
+    from labthings.server.wsgi import Server
+
+    server = Server(app)
+    server.run(host="0.0.0.0", port=5000, debug=False)

openflexure_microscope/api/default_extensions/__init__.py

@@ -14,3 +14,5 @@ except Exception as e:
     logging.error(
         f"Exception loading builtin extension picamera_autocalibrate: \n{traceback.format_exc()}"
     )
+
+from ..example_extensions.custom_element import customelement_extension_v2

openflexure_microscope/api/default_extensions/autostorage.py

@@ -241,6 +241,7 @@ def dynamic_form():
     return {
         "icon": "sd_storage",
         "title": "Storage",
+        "viewPanel": "gallery",
         "forms": [
             {
                 "name": "Autostorage",

openflexure_microscope/api/example_extensions/custom_element/__init__.py

@@ -0,0 +1,57 @@
+from labthings.server.extensions import BaseExtension
+from labthings.server.view import View
+from labthings.server.decorators import ThingProperty, PropertySchema, use_args
+from labthings.server import fields
+from labthings.server.find import find_component
+from labthings.core.utilities import path_relative_to
+
+from openflexure_microscope.paths import settings_file_path, check_rw
+from openflexure_microscope.config import OpenflexureSettingsFile
+from openflexure_microscope.camera.base import BASE_CAPTURE_PATH
+from openflexure_microscope.camera.capture import build_captures_from_exif
+
+from openflexure_microscope.api.utilities.gui import build_gui
+
+from flask import abort, url_for
+import logging
+import os
+import psutil
+
+from sys import platform
+
+
+class CustomElementExtension(BaseExtension):
+    def __init__(self):
+        BaseExtension.__init__(
+            self,
+            "org.openflexure.customelement",
+            description="Testing HTML components in an extension",
+            static_folder=path_relative_to(__file__, "static"),
+        )
+
+        # Register the on_microscope function to run when the microscope is attached
+        self.on_component("org.openflexure.microscope", self.on_microscope)
+
+    def on_microscope(self, microscope_obj):
+        """Function to automatically call when the parent LabThing has a microscope attached."""
+        logging.debug(f"CustomElementExtension found microscope {microscope_obj}")
+
+
+customelement_extension_v2 = CustomElementExtension()
+
+
+def wc_func():
+    return {
+        "href": customelement_extension_v2.static_file_url("my-custom-element.min.js"),
+        "name": "my-custom-element",
+    }
+
+
+def gui_func():
+    return {"icon": "pets", "title": "Element", "viewPanel": "stream", "wc": wc_func()}
+
+
+customelement_extension_v2.add_meta("wc", wc_func)
+customelement_extension_v2.add_meta(
+    "gui", build_gui(gui_func, customelement_extension_v2)
+)

openflexure_microscope/api/v2/views/captures.py

@@ -207,7 +207,7 @@ class CaptureTags(View):
 
         return jsonify(capture_obj.tags)
 
-    def delete(self, capture_id):
+    def delete(self, id):
         """
         Delete tags from a single image capture
         """

openflexure_microscope/api/v2/views/streams.py

@@ -18,7 +18,16 @@ class MjpegStream(View):
     @doc_response(200, mimetype="multipart/x-mixed-replace")
     def get(self):
         """
-        MJPEG stream from the microscope camera
+        MJPEG stream from the microscope camera.
+
+        Note: While the code actually getting frame data from a camera and storing it in
+        camera.frame runs in a thread, the gen(microscope.camera) generator does not.
+        This response is therefore blocking. The generator just yields the most recent
+        frame from the camera object, passed to the Flask response, and then repeats until
+        the connection is closed.
+
+        Without monkey patching with gevent, or using a native threaded server, the stream
+        will block all proceeding requests.
         """
         microscope = find_component("org.openflexure.microscope")
         # Restart stream worker thread

openflexure_microscope/camera/base.py

@@ -3,6 +3,7 @@ import time
 import os
 import shutil
 import threading
+import gevent.event
 import datetime
 import logging
 
@@ -61,7 +62,7 @@ class CameraEvent(object):
             # this is a new client
             # add an entry for it in the self.events dict
             # each entry has two elements, a threading.Event() and a timestamp
-            self.events[ident] = [threading.Event(), time.time()]
+            self.events[ident] = [gevent.event.Event(), time.time()]
         return self.events[ident][0].wait(timeout)
 
     def set(self):
@@ -181,65 +182,6 @@ class BaseCamera(metaclass=ABCMeta):
     def rebuild_captures(self):
         self.images = build_captures_from_exif(self.paths["default"])
 
-    # START AND STOP WORKER THREAD
-
-    def start_worker(self, timeout: int = 5) -> bool:
-        """Start the background camera thread if it isn't running yet."""
-        timeout_time = time.time() + timeout
-
-        self.last_access = time.time()
-        self.stop = False
-
-        if not self.stream_active:
-            # start background frame thread
-            self.thread = threading.Thread(target=self._thread)
-            self.thread.daemon = True
-            self.thread.start()
-
-            # wait until frames are available
-            logging.info("Waiting for frames")
-            while self.get_frame() is None:
-                if time.time() > timeout_time:
-                    raise TimeoutError("Timeout waiting for frames.")
-                else:
-                    time.sleep(0.1)
-        return True
-
-    def stop_worker(self, timeout: int = 5) -> bool:
-        """Flag worker thread for stop. Waits for thread close or timeout."""
-        logging.debug("Stopping worker thread")
-        timeout_time = time.time() + timeout
-
-        if self.stream_active:
-            self.stop = True
-            self.thread.join()  # Wait for stream thread to exit
-            logging.debug("Waiting for stream thread to exit.")
-
-        while self.stream_active:
-            if time.time() > timeout_time:
-                logging.debug("Timeout waiting for worker thread close.")
-                raise TimeoutError("Timeout waiting for worker thread close.")
-            else:
-                time.sleep(0.1)
-        return True
-
-    # HANDLE STREAM FRAMES
-
-    def get_frame(self):
-        """Return the current camera frame."""
-        self.last_access = time.time()
-
-        # wait for a signal from the camera thread
-        self.event.wait()
-        self.event.clear()
-
-        return self.frame
-
-    @abstractmethod
-    def frames(self):
-        """Create generator that returns frames from the camera."""
-        pass
-
     # RETURNING CAPTURES
 
     @property
@@ -355,6 +297,65 @@ class BaseCamera(metaclass=ABCMeta):
 
         return output
 
+    # START AND STOP WORKER THREAD
+
+    def start_worker(self, timeout: int = 5) -> bool:
+        """Start the background camera thread if it isn't running yet."""
+        timeout_time = time.time() + timeout
+
+        self.last_access = time.time()
+        self.stop = False
+
+        if not self.stream_active:
+            # start background frame thread
+            self.thread = threading.Thread(target=self._thread)
+            self.thread.daemon = True
+            self.thread.start()
+
+            # wait until frames are available
+            logging.info("Waiting for frames")
+            while self.get_frame() is None:
+                if time.time() > timeout_time:
+                    raise TimeoutError("Timeout waiting for frames.")
+                else:
+                    time.sleep(0.1)
+        return True
+
+    def stop_worker(self, timeout: int = 5) -> bool:
+        """Flag worker thread for stop. Waits for thread close or timeout."""
+        logging.debug("Stopping worker thread")
+        timeout_time = time.time() + timeout
+
+        if self.stream_active:
+            self.stop = True
+            self.thread.join()  # Wait for stream thread to exit
+            logging.debug("Waiting for stream thread to exit.")
+
+        while self.stream_active:
+            if time.time() > timeout_time:
+                logging.debug("Timeout waiting for worker thread close.")
+                raise TimeoutError("Timeout waiting for worker thread close.")
+            else:
+                time.sleep(0.1)
+        return True
+
+    # HANDLE STREAM FRAMES
+
+    def get_frame(self):
+        """Return the current camera frame."""
+        self.last_access = time.time()
+
+        # wait for a signal from the camera thread
+        self.event.wait()
+        self.event.clear()
+
+        return self.frame
+
+    @abstractmethod
+    def frames(self):
+        """Create generator that returns frames from the camera."""
+        pass
+
     # WORKER THREAD
 
     def _thread(self):

openflexure_microscope/camera/mock.py

@@ -10,6 +10,7 @@ import time
 import numpy as np
 from PIL import Image, ImageFont, ImageDraw
 from datetime import datetime
+import gevent
 
 import logging
 
@@ -224,7 +225,7 @@ class MissingCamera(BaseCamera):
         # While the iterator is not closed
         try:
             while True:
-                time.sleep(1)  # Only serve frames at 1fps
+                gevent.sleep(1)  # Only serve frames at 1fps
                 # Reset stream
                 self.stream.seek(0)
                 self.stream.truncate()