MSS: the implementation is now thread-safe on all OSes

Author: BoboTiG

CHANGELOG

@@ -2,10 +2,10 @@ History:
 
 <see Git checking messages for history>
 
-5.1.1   2020/xx/xx
+6.0.0   2020/xx/xx
       - removed usage of deprecated "license_file" option for "license_files"
       - fixed flake8 usage in pre-commit
-      - Linux: the implementation is now thread-safe (fixes #169)
+      - MSS: the implementation is now thread-safe on all OSes (fixes #169)
       - :heart: contributors: @
 
 5.1.0   2020/04/30

CHANGES.rst

@@ -1,7 +1,30 @@
-5.1.1 (2020-xx-xx)
+6.0.0 (2020-xx-xx)
 ==================
 
+base.py
+-------
+ - Added ``lock``
+ - Added ``MSS._grab_impl()`` (abstract method)
+ - Added ``MSS._monitors_impl()`` (abstract method)
+ - ``MSS.grab()`` is no more an abstract method
+ - ``MSS.monitors`` is no more an abstract property
+
+darwin.py
+---------
+ - Renamed ``MSS.grab()`` to ``MSS._grab_impl()``
+ - Renamed ``MSS.monitors`` to ``MSS._monitors_impl()``
 
+linux.py
+--------
+ - Renamed ``MSS.grab()`` to ``MSS._grab_impl()``
+ - Renamed ``MSS.monitors`` to ``MSS._monitors_impl()``
+
+windows.py
+----------
+ - Removed ``MSS._lock``
+ - Renamed ``MSS.srcdc_dict`` to ``MSS._srcdc_dict``
+ - Renamed ``MSS.grab()`` to ``MSS._grab_impl()``
+ - Renamed ``MSS.monitors`` to ``MSS._monitors_impl()``
 
 
 5.1.0 (2020-04-30)

README.rst

@@ -22,7 +22,7 @@ Python MSS
 
 An ultra fast cross-platform multiple screenshots module in pure python using ctypes.
 
-- **Python 3.5+** and PEP8 compliant, no dependency;
+- **Python 3.5+** and PEP8 compliant, no dependency, thread-safe;
 - very basic, it will grab one screen shot by monitor or a screen shot of all monitors and save it to a PNG file;
 - but you can use PIL and benefit from all its formats (or add yours directly);
 - integrate well with Numpy and OpenCV;

docs/source/conf.py

@@ -27,7 +27,7 @@
 # built documents.
 #
 # The short X.Y version.
-version = "5.1.1"
+version = "6.0.0"
 
 # The full version, including alpha/beta/rc tags.
 release = "latest"

docs/source/index.rst

@@ -12,7 +12,7 @@ Welcome to Python MSS's documentation!
 
 An ultra fast cross-platform multiple screenshots module in pure python using ctypes.
 
-    - **Python 3.5+** and :pep:`8` compliant, no dependency;
+    - **Python 3.5+** and :pep:`8` compliant, no dependency, thread-safe;
     - very basic, it will grab one screen shot by monitor or a screen shot of all monitors and save it to a PNG file;
     - but you can use PIL and benefit from all its formats (or add yours directly);
     - integrate well with Numpy and OpenCV;

mss/__init__.py

@@ -12,7 +12,7 @@
 from .exception import ScreenShotError
 from .factory import mss
 
-__version__ = "5.1.1"
+__version__ = "6.0.0"
 __author__ = "Mickaël 'Tiger-222' Schoentgen"
 __copyright__ = """
     Copyright (c) 2013-2020, Mickaël 'Tiger-222' Schoentgen

mss/base.py

@@ -6,6 +6,7 @@
 from abc import ABCMeta, abstractmethod
 from datetime import datetime
 from typing import TYPE_CHECKING
+from threading import Lock
 
 from .exception import ScreenShotError
 from .screenshot import ScreenShot
@@ -17,6 +18,9 @@
     from .models import Monitor, Monitors  # noqa
 
 
+lock = Lock()
+
+
 class MSSBase(metaclass=ABCMeta):
     """ This class will be overloaded by a system specific one. """
 
@@ -38,23 +42,51 @@ def __exit__(self, *_):
 
         self.close()
 
+    @abstractmethod
+    def _grab_impl(self, monitor):
+        # type: (Monitor) -> ScreenShot
+        """
+        Retrieve all pixels from a monitor. Pixels have to be RGB.
+        That method has to be run using a threading lock.
+        """
+
+    @abstractmethod
+    def _monitors_impl(self):
+        # type: () -> None
+        """
+        Get positions of monitors (has to be run using a threading lock).
+        It must populate self._monitors.
+        """
+
     def close(self):
         # type: () -> None
         """ Clean-up. """
 
-    @abstractmethod
     def grab(self, monitor):
         # type: (Monitor) -> ScreenShot
         """
         Retrieve screen pixels for a given monitor.
 
+        Note: *monitor* can be a tuple like PIL.Image.grab() accepts.
+
         :param monitor: The coordinates and size of the box to capture.
                         See :meth:`monitors <monitors>` for object details.
         :return :class:`ScreenShot <ScreenShot>`.
         """
 
+        # Convert PIL bbox style
+        if isinstance(monitor, tuple):
+            monitor = {
+                "left": monitor[0],
+                "top": monitor[1],
+                "width": monitor[2] - monitor[0],
+                "height": monitor[3] - monitor[1],
+            }
+
+        with lock:
+            return self._grab_impl(monitor)
+
     @property
-    @abstractmethod
     def monitors(self):
         # type: () -> Monitors
         """
@@ -74,11 +106,14 @@ def monitors(self):
             'width':  the width,
             'height': the height
         }
-
-        Note: monitor can be a tuple like PIL.Image.grab() accepts,
-        it must be converted to the appropriate dict.
         """
 
+        if not self._monitors:
+            with lock:
+                self._monitors_impl()
+
+        return self._monitors
+
     def save(self, mon=0, output="monitor-{mon}.png", callback=None):
         # type: (int, str, Callable[[str], None]) -> Iterator[str]
         """

mss/darwin.py

@@ -120,75 +120,60 @@ def cfactory(func, argtypes, restype):
         cfactory(func="CGDataProviderRelease", argtypes=[void], restype=void)
         cfactory(func="CFRelease", argtypes=[void], restype=void)
 
-    @property
-    def monitors(self):
-        # type: () -> Monitors
-        """ Get positions of monitors (see parent class). """
-
-        if not self._monitors:
-            int_ = int
-            core = self.core
-
-            # All monitors
-            # We need to update the value with every single monitor found
-            # using CGRectUnion.  Else we will end with infinite values.
-            all_monitors = CGRect()
-            self._monitors.append({})
-
-            # Each monitors
-            display_count = ctypes.c_uint32(0)
-            active_displays = (ctypes.c_uint32 * self.max_displays)()
-            core.CGGetActiveDisplayList(
-                self.max_displays, active_displays, ctypes.byref(display_count)
+    def _monitors_impl(self):
+        # type: () -> None
+        """ Get positions of monitors. It will populate self._monitors. """
+
+        int_ = int
+        core = self.core
+
+        # All monitors
+        # We need to update the value with every single monitor found
+        # using CGRectUnion.  Else we will end with infinite values.
+        all_monitors = CGRect()
+        self._monitors.append({})
+
+        # Each monitors
+        display_count = ctypes.c_uint32(0)
+        active_displays = (ctypes.c_uint32 * self.max_displays)()
+        core.CGGetActiveDisplayList(
+            self.max_displays, active_displays, ctypes.byref(display_count)
+        )
+        rotations = {0.0: "normal", 90.0: "right", -90.0: "left"}
+        for idx in range(display_count.value):
+            display = active_displays[idx]
+            rect = core.CGDisplayBounds(display)
+            rect = core.CGRectStandardize(rect)
+            width, height = rect.size.width, rect.size.height
+            rot = core.CGDisplayRotation(display)
+            if rotations[rot] in ["left", "right"]:
+                width, height = height, width
+            self._monitors.append(
+                {
+                    "left": int_(rect.origin.x),
+                    "top": int_(rect.origin.y),
+                    "width": int_(width),
+                    "height": int_(height),
+                }
             )
-            rotations = {0.0: "normal", 90.0: "right", -90.0: "left"}
-            for idx in range(display_count.value):
-                display = active_displays[idx]
-                rect = core.CGDisplayBounds(display)
-                rect = core.CGRectStandardize(rect)
-                width, height = rect.size.width, rect.size.height
-                rot = core.CGDisplayRotation(display)
-                if rotations[rot] in ["left", "right"]:
-                    width, height = height, width
-                self._monitors.append(
-                    {
-                        "left": int_(rect.origin.x),
-                        "top": int_(rect.origin.y),
-                        "width": int_(width),
-                        "height": int_(height),
-                    }
-                )
-
-                # Update AiO monitor's values
-                all_monitors = core.CGRectUnion(all_monitors, rect)
-
-            # Set the AiO monitor's values
-            self._monitors[0] = {
-                "left": int_(all_monitors.origin.x),
-                "top": int_(all_monitors.origin.y),
-                "width": int_(all_monitors.size.width),
-                "height": int_(all_monitors.size.height),
-            }
-
-        return self._monitors
-
-    def grab(self, monitor):
+
+            # Update AiO monitor's values
+            all_monitors = core.CGRectUnion(all_monitors, rect)
+
+        # Set the AiO monitor's values
+        self._monitors[0] = {
+            "left": int_(all_monitors.origin.x),
+            "top": int_(all_monitors.origin.y),
+            "width": int_(all_monitors.size.width),
+            "height": int_(all_monitors.size.height),
+        }
+
+    def _grab_impl(self, monitor):
         # type: (Monitor) -> ScreenShot
-        """
-        See :meth:`MSSBase.grab <mss.base.MSSBase.grab>` for full details.
-        """
+        """ Retrieve all pixels from a monitor. Pixels have to be RGB. """
 
         # pylint: disable=too-many-locals
 
-        # Convert PIL bbox style
-        if isinstance(monitor, tuple):
-            monitor = {
-                "left": monitor[0],
-                "top": monitor[1],
-                "width": monitor[2] - monitor[0],
-                "height": monitor[3] - monitor[1],
-            }
-
         core = self.core
         rect = CGRect(
             (monitor["left"], monitor["top"]), (monitor["width"], monitor["height"])

mss/linux.py

@@ -191,9 +191,6 @@ class MSS(MSSBase):
     # A dict to maintain *display* values created by multiple threads.
     _display_dict = {}  # type: Dict[threading.Thread, int]
 
-    # A threading lock to lock resources.
-    _lock = threading.Lock()
-
     def __init__(self, display=None):
         # type: (Optional[Union[bytes, str]]) -> None
         """ GNU/Linux initialisations. """
@@ -359,10 +356,7 @@ def get_error_details(self):
 
     def _monitors_impl(self):
         # type: () -> None
-        """
-        Get positions of monitors (has to be run using a threading lock).
-        It will populate self._monitors.
-        """
+        """ Get positions of monitors. It will populate self._monitors. """
 
         display = self._get_display()
         int_ = int
@@ -400,32 +394,9 @@ def _monitors_impl(self):
             xrandr.XRRFreeCrtcInfo(crtc)
         xrandr.XRRFreeScreenResources(mon)
 
-    @property
-    def monitors(self):
-        # type: () -> Monitors
-        """ Get positions of monitors (see parent class property). """
-
-        if not self._monitors:
-            with MSS._lock:
-                self._monitors_impl()
-
-        return self._monitors
-
     def _grab_impl(self, monitor):
         # type: (Monitor) -> ScreenShot
-        """
-        Retrieve all pixels from a monitor. Pixels have to be RGB.
-        That method has to be run using a threading lock.
-        """
-
-        # Convert PIL bbox style
-        if isinstance(monitor, tuple):
-            monitor = {
-                "left": monitor[0],
-                "top": monitor[1],
-                "width": monitor[2] - monitor[0],
-                "height": monitor[3] - monitor[1],
-            }
+        """ Retrieve all pixels from a monitor. Pixels have to be RGB. """
 
         ximage = self.xlib.XGetImage(
             self._get_display(),
@@ -459,10 +430,3 @@ def _grab_impl(self, monitor):
             self.xlib.XDestroyImage(ximage)
 
         return self.cls_image(data, monitor)
-
-    def grab(self, monitor):
-        # type: (Monitor) -> ScreenShot
-        """ Retrieve all pixels from a monitor. Pixels have to be RGB. """
-
-        with MSS._lock:
-            return self._grab_impl(monitor)