Merge branch 'master' of github.com:jonathanrocher/ets_tutorial

Author: jonathanrocher

slides/07_background_processing.md

@@ -0,0 +1,54 @@
+---
+jupyter:
+  jupytext:
+    text_representation:
+      extension: .md
+      format_name: markdown
+      format_version: '1.3'
+      jupytext_version: 1.14.0
+  kernelspec:
+    display_name: Python 3 (ipykernel)
+    language: python
+    name: python3
+---
+
+<!-- #region slideshow={"slide_type": "slide"} -->
+## Sharing scientific tools: script to desktop application
+
+### Background processing with Traits Futures
+
+**Jonathan Rocher, Siddhant Wahal, Jason Chambless, Corran Webster, Prabhu Ramachandran**
+
+**SciPy 2022**
+
+<!-- #endregion -->
+
+<!-- #region slideshow={"slide_type": "slide"} -->
+## Traits Futures:
+
+- Common problems with GUI frameworks:
+    - GUIs are unresponsive during heavy computation
+    - GUI toolkits generally require that widgets are only updated from the
+      thread from which they were created
+- Traits Futures solves both these problems:
+    - keeping the UI responsive
+    - safely update the UI in response to calculation results
+- Dispatching a background task returns a `future` object which provides:
+    - information about job status (e.g., job partially finished, completed,
+      failed)
+    - access to the job result
+- Incoming results arrive as trait changes on the main thread, ensuring thread
+  safety
+- Supports simple callbacks, iterations, and progress-reporting functions
+- Supports thread pools (default) and process pools
+
+<!-- #endregion -->
+
+<!-- #region slideshow={"slide_type": "slide"} -->
+## Traits Futures
+- Let's dive in with an example
+- Installation:
+    - `edm install -e ets_tutorial traits_futures`
+    - Conda/pip: Activate virtual environment and `pip install traits_futures`
+
+<!-- #endregion -->

stage7.1_background_proc/README.md

@@ -0,0 +1,2 @@
+Building on the application state in stage 6, this version adds background processing
+of image folders using traits futures.

stage7.1_background_proc/pycasa/__init__.py

@@ -0,0 +1,68 @@
+# coding=utf-8
+""" TaskApplication object for the Pycasa app.
+"""
+import logging
+
+from pyface.tasks.api import TasksApplication, TaskFactory
+from pyface.api import SplashScreen
+from pyface.action.api import Action
+from pyface.action.schema.api import SchemaAddition, SGroup
+
+from ..ui.tasks.pycasa_task import PycasaTask
+from ..ui.image_resources import app_icon, new_icon
+
+logger = logging.getLogger(__name__)
+
+
+class PycasaApplication(TasksApplication):
+    """ An application to explore image files and detect faces.
+    """
+    id = "pycasa_application"
+
+    name = "Pycasa"
+
+    description = "An example Tasks application that explores image files."
+
+    def _task_factories_default(self):
+        return [
+            TaskFactory(
+                id='pycasa.pycasa_task_factory',
+                name="Main Pycasa Task Factory",
+                factory=PycasaTask
+            )
+        ]
+
+    def _icon_default(self):
+        return app_icon
+
+    def _splash_screen_default(self):
+        splash_screen = SplashScreen(image=app_icon)
+        return splash_screen
+
+    def create_new_task_window(self):
+        from pyface.tasks.task_window_layout import TaskWindowLayout
+
+        layout = TaskWindowLayout()
+        layout.items = [self.task_factories[0].id]
+        window = self.create_window(layout=layout)
+        self.add_window(window)
+        window.title += " {}".format(len(self.windows))
+        return window
+
+    def create_new_task_menu(self):
+        return SGroup(
+            Action(name="New",
+                   accelerator='Ctrl+N',
+                   on_perform=self.create_new_task_window,
+                   image=new_icon),
+            id='NewGroup', name='NewGroup',
+        )
+
+    def _extra_actions_default(self):
+        extra_actions = [
+            SchemaAddition(id='pycasa.custom_new',
+                           factory=self.create_new_task_menu,
+                           path="MenuBar/File/OpenGroup",
+                           absolute_position="first")
+        ]
+        return extra_actions

stage7.1_background_proc/pycasa/app/__init__.py

@@ -0,0 +1,11 @@
+
+from pycasa.app.app import PycasaApplication
+
+
+def main():
+    app = PycasaApplication()
+    app.run()
+
+
+if __name__ == '__main__':
+    main()

stage7.1_background_proc/pycasa/app/app.py

@@ -0,0 +1,9 @@
+from os.path import expanduser
+from traits.api import Directory, Event, HasStrictTraits
+
+
+class FileBrowser(HasStrictTraits):
+    root = Directory(expanduser("~"))
+
+    #: Item last double-clicked on in the tree view
+    requested_item = Event

stage7.1_background_proc/pycasa/app/main.py

@@ -0,0 +1,64 @@
+# General imports
+from os.path import splitext
+import PIL.Image
+from PIL.ExifTags import TAGS
+from skimage import data
+from skimage.feature import Cascade
+import numpy as np
+
+# ETS imports
+from traits.api import (
+    Array, cached_property, Dict, File, HasStrictTraits, List, Property
+)
+
+SUPPORTED_FORMATS = [".png", ".jpg", ".jpeg", ".PNG", ".JPG", ".JPEG"]
+
+
+class ImageFile(HasStrictTraits):
+    """ Model to hold an image file.
+    """
+    filepath = File
+
+    metadata = Property(Dict, depends_on="filepath")
+
+    data = Property(Array, depends_on="filepath")
+
+    faces = List
+
+    def _is_valid_file(self):
+        return (
+            bool(self.filepath) and
+            splitext(self.filepath)[1].lower() in SUPPORTED_FORMATS
+        )
+
+    @cached_property
+    def _get_data(self):
+        if not self._is_valid_file():
+            return np.array([])
+        with PIL.Image.open(self.filepath) as img:
+            return np.asarray(img)
+
+    @cached_property
+    def _get_metadata(self):
+        if not self._is_valid_file():
+            return {}
+        with PIL.Image.open(self.filepath) as img:
+            exif = img._getexif()
+        if not exif:
+            return {}
+        return {TAGS[k]: v for k, v in exif.items() if k in TAGS}
+
+    def detect_faces(self):
+        # Load the trained file from the module root.
+        trained_file = data.lbp_frontal_face_cascade_filename()
+
+        # Initialize the detector cascade.
+        detector = Cascade(trained_file)
+
+        detected = detector.detect_multi_scale(img=self.data,
+                                               scale_factor=1.2,
+                                               step_ratio=1,
+                                               min_size=(60, 60),
+                                               max_size=(600, 600))
+        self.faces = detected
+        return self.faces

stage7.1_background_proc/pycasa/model/__init__.py

@@ -0,0 +1,95 @@
+# General imports
+import glob
+from os.path import basename, expanduser, isdir
+
+import numpy as np
+import pandas as pd
+
+# ETS imports
+from traits.api import (
+    Bool, Directory, Event, HasStrictTraits, Instance, List, observe, Property
+)
+from traits_futures.api import (
+    CallFuture, submit_call, TraitsExecutor
+)
+
+# Local imports
+from pycasa.model.image_file import ImageFile, SUPPORTED_FORMATS
+
+FILENAME_COL = "filename"
+NUM_FACE_COL = "Num. faces"
+
+
+class ImageFolder(HasStrictTraits):
+    """ Model for a folder of images.
+    """
+    directory = Directory(expanduser("~"))
+
+    images = List(Instance(ImageFile))
+
+    data = Instance(pd.DataFrame)
+
+    data_updated = Event
+
+    traits_executor = Instance(TraitsExecutor)
+
+    future = Instance(CallFuture)
+
+    executor_idle = Property(Bool, depends_on="future.done")
+
+    def __init__(self, **traits):
+        # Don't forget this!
+        super(ImageFolder, self).__init__(**traits)
+        if not isdir(self.directory):
+            msg = f"The provided directory isn't a real directory: " \
+                  f"{self.directory}"
+            raise ValueError(msg)
+        self.data = self._create_metadata_df()
+
+    @observe("directory")
+    def _update_images(self, event):
+        self.images = [
+            ImageFile(filepath=file)
+            for fmt in SUPPORTED_FORMATS
+            for file in glob.glob(f"{self.directory}/*{fmt}")
+        ]
+
+    @observe("images.items")
+    def _update_metadata(self, event):
+        self.data = self._create_metadata_df()
+
+    def _create_metadata_df(self):
+        if not self.images:
+            return pd.DataFrame({FILENAME_COL: [], NUM_FACE_COL: []})
+        return pd.DataFrame([
+                {
+                    FILENAME_COL: basename(img.filepath),
+                    NUM_FACE_COL: np.nan,
+                    **img.metadata
+
+                }
+                for img in self.images
+        ])
+
+    def compute_num_faces_background(self, **kwargs):
+        self.future = submit_call(
+            self.traits_executor,
+            self._compute_num_faces,
+            **kwargs
+        )
+
+    def _compute_num_faces(self, **kwargs):
+        return [
+            len(img_file.detect_faces(**kwargs))
+            for img_file in self.images
+        ]
+
+    @observe("future:done")
+    def _update_data(self, event):
+        num_faces_all_images = self.future.result
+        for idx, num_faces in enumerate(num_faces_all_images):
+            self.data[NUM_FACE_COL].iat[idx] = num_faces
+        self.data_updated = True
+
+    def _get_executor_idle(self):
+        return self.future is None or self.future.done