From 35ebcb33a3275f335f6a86b283e8d5a65676a4e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Edouard=20Choini=C3=A8re?=
 <27212526+echoix@users.noreply.github.com>
Date: Sun, 3 Nov 2024 10:59:24 -0500
Subject: [PATCH] python: Add typing to RPC server and Messenger (#4639)

* grass.pygrass.rpc.base: Add typing annotations for lock and conn

* grass.pygrass.rpc.base: Use context manager for lock in dummy_server

* grass.pygrass.rpc.base: Use context manager for threadLock in RPCServerBase

* grass.pygrass.rpc.base: Remove release lock in context manager

* grass.pygrass.rpc.base: Add more typing annotations

* grass.pygrass.rpc.base: Check for None to satisfy mypy type checking

* grass.pygrass.rpc.base: Remove release lock in context managers, as they would be released when unlocked (RuntimeError: release unlocked lock)

* grass.pygrass.rpc.base: Sort imports

* grass.temporal.c_libraries_interface: Use context manager for lock in c_library_server

* grass.temporal.c_libraries_interface: Add typing annotations for lock and conn

* grass.pygrass.rpc.base: Change date of file header

* grass.pygrass.rpc.base: Update docs of conn argument to mention that it is a multiprocessing.Connection object obtained from multiprocessing.Pipe

* grass.temporal.c_libraries_interface: Change date of file header

* grass.pygrass.rpc: Sort imports

* grass.temporal.c_libraries_interface: Sort imports

* Update docs of conn argument to mention that it is a multiprocessing.Connection object obtained from multiprocessing.Pipe

* grass.pygrass.messages: Sort imports

* Update docs of conn argument to mention that it is a multiprocessing.connection.Connection object obtained from multiprocessing.Pipe

* grass.pygrass.rpc: Use context manager to acquire and release the lock

* Fix typo in python/grass/pygrass/messages/testsuite/test_pygrass_messages_doctests.py

* grass.pygrass.messages: Fix typo in message_server

* grass.pygrass.messages: Missing "IMPORTANT" message type in message_server

* grass.pygrass.messages: Add return type to get_msgr

* grass.pygrass.messages: Add types to signatures in Messenger class and rest of file

* grass.pygrass.messages: Use context manager for acquiring the lock in message_server()

* grass.pygrass.messages: Add types to message_types to track missing conditions

* grass.pygrass.messages: Extract message only for message_types where the variable is used

* grass.pygrass.messages: Add parameter descriptions to percent(self, n, d, s)

* grass.pygrass.messages: Initialize Messenger fields without setting them to None

* grass.pygrass.messages: Fix typo

* grass.pygrass.messages: Change date of file header
---
 python/grass/pygrass/messages/__init__.py     | 158 +++++++++---------
 .../test_pygrass_messages_doctests.py         |   2 +-
 python/grass/pygrass/rpc/__init__.py          |  29 ++--
 python/grass/pygrass/rpc/base.py              | 107 ++++++------
 .../grass/temporal/c_libraries_interface.py   | 108 +++++++-----
 5 files changed, 223 insertions(+), 181 deletions(-)

diff --git a/python/grass/pygrass/messages/__init__.py b/python/grass/pygrass/messages/__init__.py
index 54d9af1b1c5..b5fe052883c 100644
--- a/python/grass/pygrass/messages/__init__.py
+++ b/python/grass/pygrass/messages/__init__.py
@@ -6,34 +6,45 @@
 Fast and exit-safe interface to GRASS C-library message functions
 
 
-(C) 2013 by the GRASS Development Team
+(C) 2013-2024 by the GRASS Development Team
 This program is free software under the GNU General Public
 License (>=v2). Read the file COPYING that comes with GRASS
 for details.
 
-@author Soeren Gebbert
+@author Soeren Gebbert, Edouard Choinière
 """
 
+from __future__ import annotations
+
 import sys
-from multiprocessing import Process, Lock, Pipe
+from multiprocessing import Lock, Pipe, Process
+from typing import TYPE_CHECKING, Literal, NoReturn
 
 import grass.lib.gis as libgis
-
 from grass.exceptions import FatalError
 
+if TYPE_CHECKING:
+    from multiprocessing.connection import Connection
+    from multiprocessing.context import _LockLike
+
+    _MessagesLiteral = Literal[
+        "INFO", "IMPORTANT", "VERBOSE", "WARNING", "ERROR", "FATAL"
+    ]
+
 
-def message_server(lock, conn):
+def message_server(lock: _LockLike, conn: Connection) -> NoReturn:
     """The GRASS message server function designed to be a target for
     multiprocessing.Process
 
 
     :param lock: A multiprocessing.Lock
-    :param conn: A multiprocessing.Pipe
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe
 
     This function will use the G_* message C-functions from grass.lib.gis
     to provide an interface to the GRASS C-library messaging system.
 
-    The data that is send through the pipe must provide an
+    The data that is sent through the pipe must provide an
     identifier string to specify which C-function should be called.
 
     The following identifiers are supported:
@@ -52,9 +63,9 @@ def message_server(lock, conn):
     - "FATAL"      Calls G_fatal_error(), this functions is only for
                    testing purpose
 
-    The that is end through the pipe must be a list of values:
+    The data that is sent through the pipe must be a list of values:
 
-    - Messages: ["INFO|VERBOSE|WARNING|ERROR|FATAL", "MESSAGE"]
+    - Messages: ["INFO|IMPORTANT|VERBOSE|WARNING|ERROR|FATAL", "MESSAGE"]
     - Debug:    ["DEBUG", level, "MESSAGE"]
     - Percent:  ["PERCENT", n, d, s]
 
@@ -65,44 +76,42 @@ def message_server(lock, conn):
         # Avoid busy waiting
         conn.poll(None)
         data = conn.recv()
-        message_type = data[0]
+        message_type: Literal[_MessagesLiteral, "DEBUG", "PERCENT", "STOP"] = data[0]
 
         # Only one process is allowed to write to stderr
-        lock.acquire()
-
-        # Stop the pipe and the infinite loop
-        if message_type == "STOP":
-            conn.close()
-            lock.release()
-            libgis.G_debug(1, "Stop messenger server")
-            sys.exit()
-
-        message = data[1]
-
-        if message_type == "PERCENT":
-            n = int(data[1])
-            d = int(data[2])
-            s = int(data[3])
-            libgis.G_percent(n, d, s)
-        elif message_type == "DEBUG":
-            level = data[1]
-            message = data[2]
-            libgis.G_debug(level, message)
-        elif message_type == "VERBOSE":
-            libgis.G_verbose_message(message)
-        elif message_type == "INFO":
-            libgis.G_message(message)
-        elif message_type == "IMPORTANT":
-            libgis.G_important_message(message)
-        elif message_type == "WARNING":
-            libgis.G_warning(message)
-        elif message_type == "ERROR":
-            libgis.G_important_message("ERROR: %s" % message)
-        # This is for testing only
-        elif message_type == "FATAL":
-            libgis.G_fatal_error(message)
-
-        lock.release()
+        with lock:
+            # Stop the pipe and the infinite loop
+            if message_type == "STOP":
+                conn.close()
+                libgis.G_debug(1, "Stop messenger server")
+                sys.exit()
+
+            if message_type == "PERCENT":
+                n = int(data[1])
+                d = int(data[2])
+                s = int(data[3])
+                libgis.G_percent(n, d, s)
+                continue
+            if message_type == "DEBUG":
+                level = int(data[1])
+                message_debug = data[2]
+                libgis.G_debug(level, message_debug)
+                continue
+
+            message: str = data[1]
+            if message_type == "VERBOSE":
+                libgis.G_verbose_message(message)
+            elif message_type == "INFO":
+                libgis.G_message(message)
+            elif message_type == "IMPORTANT":
+                libgis.G_important_message(message)
+            elif message_type == "WARNING":
+                libgis.G_warning(message)
+            elif message_type == "ERROR":
+                libgis.G_important_message("ERROR: %s" % message)
+            # This is for testing only
+            elif message_type == "FATAL":
+                libgis.G_fatal_error(message)
 
 
 class Messenger:
@@ -165,14 +174,19 @@ class Messenger:
 
     """
 
-    def __init__(self, raise_on_error=False):
-        self.client_conn = None
-        self.server_conn = None
-        self.server = None
+    client_conn: Connection
+    server_conn: Connection
+    server: Process
+
+    def __init__(self, raise_on_error: bool = False) -> None:
         self.raise_on_error = raise_on_error
-        self.start_server()
+        self.client_conn, self.server_conn = Pipe()
+        self.lock = Lock()
+        self.server = Process(target=message_server, args=(self.lock, self.server_conn))
+        self.server.daemon = True
+        self.server.start()
 
-    def start_server(self):
+    def start_server(self) -> None:
         """Start the messenger server and open the pipe"""
         self.client_conn, self.server_conn = Pipe()
         self.lock = Lock()
@@ -180,7 +194,7 @@ def start_server(self):
         self.server.daemon = True
         self.server.start()
 
-    def _check_restart_server(self):
+    def _check_restart_server(self) -> None:
         """Restart the server if it was terminated"""
         if self.server.is_alive() is True:
             return
@@ -189,55 +203,50 @@ def _check_restart_server(self):
         self.start_server()
         self.warning("Needed to restart the messenger server")
 
-    def message(self, message):
+    def message(self, message: str) -> None:
         """Send a message to stderr
 
         :param message: the text of message
-        :type message: str
 
            G_message() will be called in the messenger server process
         """
         self._check_restart_server()
         self.client_conn.send(["INFO", message])
 
-    def verbose(self, message):
+    def verbose(self, message: str) -> None:
         """Send a verbose message to stderr
 
         :param message: the text of message
-        :type message: str
 
            G_verbose_message() will be called in the messenger server process
         """
         self._check_restart_server()
         self.client_conn.send(["VERBOSE", message])
 
-    def important(self, message):
+    def important(self, message: str) -> None:
         """Send an important message to stderr
 
         :param message: the text of message
-        :type message: str
 
            G_important_message() will be called in the messenger server process
         """
         self._check_restart_server()
         self.client_conn.send(["IMPORTANT", message])
 
-    def warning(self, message):
+    def warning(self, message: str) -> None:
         """Send a warning message to stderr
 
         :param message: the text of message
-        :type message: str
 
            G_warning() will be called in the messenger server process
         """
         self._check_restart_server()
         self.client_conn.send(["WARNING", message])
 
-    def error(self, message):
+    def error(self, message: str) -> None:
         """Send an error message to stderr
 
         :param message: the text of message
-        :type message: str
 
            G_important_message() with an additional "ERROR:" string at
            the start will be called in the messenger server process
@@ -245,11 +254,10 @@ def error(self, message):
         self._check_restart_server()
         self.client_conn.send(["ERROR", message])
 
-    def fatal(self, message):
+    def fatal(self, message: str) -> NoReturn:
         """Send an error message to stderr, call sys.exit(1) or raise FatalError
 
         :param message: the text of message
-        :type message: str
 
            This function emulates the behavior of G_fatal_error(). It prints
            an error message to stderr and calls sys.exit(1). If raise_on_error
@@ -264,30 +272,29 @@ def fatal(self, message):
             raise FatalError(message)
         sys.exit(1)
 
-    def debug(self, level, message):
+    def debug(self, level: int, message: str) -> None:
         """Send a debug message to stderr
 
         :param message: the text of message
-        :type message: str
 
            G_debug() will be called in the messenger server process
         """
         self._check_restart_server()
         self.client_conn.send(["DEBUG", level, message])
 
-    def percent(self, n, d, s):
+    def percent(self, n: int, d: int, s: int) -> None:
         """Send a percentage to stderr
 
-        :param message: the text of message
-        :type message: str
-
+        :param n: The current element
+        :param d: Total number of elements
+        :param s: Increment size
 
            G_percent() will be called in the messenger server process
         """
         self._check_restart_server()
         self.client_conn.send(["PERCENT", n, d, s])
 
-    def stop(self):
+    def stop(self) -> None:
         """Stop the messenger server and close the pipe"""
         if self.server is not None and self.server.is_alive():
             self.client_conn.send(
@@ -300,12 +307,11 @@ def stop(self):
         if self.client_conn is not None:
             self.client_conn.close()
 
-    def set_raise_on_error(self, raise_on_error=True):
+    def set_raise_on_error(self, raise_on_error: bool = True) -> None:
         """Set the fatal error behavior
 
         :param raise_on_error: if True a FatalError exception will be
                                raised instead of calling sys.exit(1)
-        :type raise_on_error: bool
 
         - If raise_on_error == True, a FatalError exception will be raised
           if fatal() is called
@@ -315,7 +321,7 @@ def set_raise_on_error(self, raise_on_error=True):
         """
         self.raise_on_error = raise_on_error
 
-    def get_raise_on_error(self):
+    def get_raise_on_error(self) -> bool:
         """Get the fatal error behavior
 
         :returns: True if a FatalError exception will be raised or False if
@@ -323,7 +329,7 @@ def get_raise_on_error(self):
         """
         return self.raise_on_error
 
-    def test_fatal_error(self, message):
+    def test_fatal_error(self, message: str) -> None:
         """Force the messenger server to call G_fatal_error()"""
         import time
 
@@ -338,7 +344,7 @@ def get_msgr(
     ],
     *args,
     **kwargs,
-):
+) -> Messenger:
     """Return a Messenger instance.
 
        :returns: the Messenger instance.
diff --git a/python/grass/pygrass/messages/testsuite/test_pygrass_messages_doctests.py b/python/grass/pygrass/messages/testsuite/test_pygrass_messages_doctests.py
index 72c20873cd6..67cd9cb3aed 100644
--- a/python/grass/pygrass/messages/testsuite/test_pygrass_messages_doctests.py
+++ b/python/grass/pygrass/messages/testsuite/test_pygrass_messages_doctests.py
@@ -28,7 +28,7 @@
 
 def load_tests(loader, tests, ignore):
     # TODO: this must be somewhere when doctest is called, not here
-    # TODO: ultimate solution is not to use _ as a buildin in lib/python
+    # TODO: ultimate solution is not to use _ as a builtin in lib/python
     # for now it is the only place where it works
     grass.gunittest.utils.do_doctest_gettext_workaround()
     # this should be called at some top level
diff --git a/python/grass/pygrass/rpc/__init__.py b/python/grass/pygrass/rpc/__init__.py
index a6ab19b9369..e95c3453250 100644
--- a/python/grass/pygrass/rpc/__init__.py
+++ b/python/grass/pygrass/rpc/__init__.py
@@ -11,17 +11,18 @@
 """
 
 import sys
-from multiprocessing import Process, Lock, Pipe
 from ctypes import CFUNCTYPE, c_void_p
+from multiprocessing import Lock, Pipe, Process
 
+import grass.lib.gis as libgis
 from grass.exceptions import FatalError
+from grass.pygrass import utils
+from grass.pygrass.gis.region import Region
+from grass.pygrass.raster import RasterRow, raster2numpy_img
 from grass.pygrass.vector import VectorTopo
 from grass.pygrass.vector.basic import Bbox
-from grass.pygrass.raster import RasterRow, raster2numpy_img
-import grass.lib.gis as libgis
+
 from .base import RPCServerBase
-from grass.pygrass.gis.region import Region
-from grass.pygrass import utils
 
 ###############################################################################
 ###############################################################################
@@ -41,7 +42,8 @@ def _get_raster_image_as_np(lock, conn, data):
     a numpy array with RGB or Gray values.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, raster_name, extent, color]
     """
     array = None
@@ -87,7 +89,8 @@ def _get_vector_table_as_dict(lock, conn, data):
     """Get the table of a vector map layer as dictionary
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, name, mapset, where]
 
     """
@@ -128,7 +131,8 @@ def _get_vector_features_as_wkb_list(lock, conn, data):
     point, centroid, line, boundary, area
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id,name,mapset,extent,
                                            feature_type, field]
 
@@ -196,7 +200,8 @@ def data_provider_server(lock, conn):
     multiprocessing.Process
 
     :param lock: A multiprocessing.Lock
-    :param conn: A multiprocessing.Pipe
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe
     """
 
     def error_handler(data):
@@ -229,9 +234,8 @@ def error_handler(data):
         # Avoid busy waiting
         conn.poll(None)
         data = conn.recv()
-        lock.acquire()
-        functions[data[0]](lock, conn, data)
-        lock.release()
+        with lock:
+            functions[data[0]](lock, conn, data)
 
 
 test_vector_name = "data_provider_vector_map"
@@ -461,6 +465,7 @@ def get_vector_features_as_wkb_list(
 
 if __name__ == "__main__":
     import doctest
+
     from grass.pygrass.modules import Module
 
     Module("g.region", n=40, s=0, e=40, w=0, res=10)
diff --git a/python/grass/pygrass/rpc/base.py b/python/grass/pygrass/rpc/base.py
index 38cf48c1581..c436300c170 100644
--- a/python/grass/pygrass/rpc/base.py
+++ b/python/grass/pygrass/rpc/base.py
@@ -2,7 +2,7 @@
 Fast and exit-safe interface to PyGRASS Raster and Vector layer
 using multiprocessing
 
-(C) 2015 by the GRASS Development Team
+(C) 2015-2024 by the GRASS Development Team
 This program is free software under the GNU General Public
 License (>=v2). Read the file COPYING that comes with GRASS
 for details.
@@ -10,35 +10,42 @@
 :authors: Soeren Gebbert
 """
 
-from grass.exceptions import FatalError
-import time
-import threading
-import sys
-from multiprocessing import Process, Lock, Pipe
+from __future__ import annotations
+
 import logging
+import sys
+import threading
+import time
+from multiprocessing import Lock, Pipe, Process
+from typing import TYPE_CHECKING, NoReturn
+
+from grass.exceptions import FatalError
+
+if TYPE_CHECKING:
+    from multiprocessing.connection import Connection
+    from multiprocessing.synchronize import _LockLike
 
 ###############################################################################
 
 
-def dummy_server(lock, conn):
+def dummy_server(lock: _LockLike, conn: Connection) -> NoReturn:
     """Dummy server process
 
     :param lock: A multiprocessing.Lock
-    :param conn: A multiprocessing.Pipe
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe
     """
 
     while True:
         # Avoid busy waiting
         conn.poll(None)
         data = conn.recv()
-        lock.acquire()
-        if data[0] == 0:
-            conn.close()
-            lock.release()
-            sys.exit()
-        if data[0] == 1:
-            raise Exception("Server process intentionally killed by exception")
-        lock.release()
+        with lock:
+            if data[0] == 0:
+                conn.close()
+                sys.exit()
+            if data[0] == 1:
+                raise Exception("Server process intentionally killed by exception")
 
 
 class RPCServerBase:
@@ -82,12 +89,12 @@ class RPCServerBase:
 
     """
 
-    def __init__(self):
-        self.client_conn = None
-        self.server_conn = None
+    def __init__(self) -> None:
+        self.client_conn: Connection | None = None
+        self.server_conn: Connection | None = None
         self.queue = None
         self.server = None
-        self.checkThread = None
+        self.checkThread: threading.Thread | None = None
         self.threadLock = threading.Lock()
         self.start_server()
         self.start_checker_thread()
@@ -96,10 +103,10 @@ def __init__(self):
         # logging.basicConfig(level=logging.DEBUG)
 
     def is_server_alive(self):
-        return self.server.is_alive()
+        return self.server.is_alive() if self.server is not None else False
 
     def is_check_thread_alive(self):
-        return self.checkThread.is_alive()
+        return self.checkThread.is_alive() if self.checkThread is not None else False
 
     def start_checker_thread(self):
         if self.checkThread is not None and self.checkThread.is_alive():
@@ -111,21 +118,19 @@ def start_checker_thread(self):
         self.checkThread.start()
 
     def stop_checker_thread(self):
-        self.threadLock.acquire()
-        self.stopThread = True
-        self.threadLock.release()
-        self.checkThread.join(None)
+        with self.threadLock:
+            self.stopThread = True
+        if self.checkThread is not None:
+            self.checkThread.join(None)
 
     def thread_checker(self):
         """Check every 200 micro seconds if the server process is alive"""
         while True:
             time.sleep(0.2)
             self._check_restart_server(caller="Server check thread")
-            self.threadLock.acquire()
-            if self.stopThread is True:
-                self.threadLock.release()
-                return
-            self.threadLock.release()
+            with self.threadLock:
+                if self.stopThread is True:
+                    return
 
     def start_server(self):
         """This function must be re-implemented in the subclasses"""
@@ -140,24 +145,25 @@ def start_server(self):
     def check_server(self):
         self._check_restart_server()
 
-    def _check_restart_server(self, caller="main thread"):
+    def _check_restart_server(self, caller="main thread") -> None:
         """Restart the server if it was terminated"""
         logging.debug("Check libgis server restart")
 
-        self.threadLock.acquire()
-        if self.server.is_alive() is True:
-            self.threadLock.release()
-            return
-        self.client_conn.close()
-        self.server_conn.close()
-        self.start_server()
-
-        if self.stopped is not True:
-            logging.warning(
-                "Needed to restart the libgis server, caller: {caller}", caller=caller
-            )
+        with self.threadLock:
+            if self.server is not None and self.server.is_alive() is True:
+                return
+            if self.client_conn is not None:
+                self.client_conn.close()
+            if self.server_conn is not None:
+                self.server_conn.close()
+            self.start_server()
+
+            if self.stopped is not True:
+                logging.warning(
+                    "Needed to restart the libgis server, caller: {caller}",
+                    caller=caller,
+                )
 
-        self.threadLock.release()
         self.stopped = False
 
     def safe_receive(self, message):
@@ -184,11 +190,12 @@ def stop(self):
 
         self.stop_checker_thread()
         if self.server is not None and self.server.is_alive():
-            self.client_conn.send(
-                [
-                    0,
-                ]
-            )
+            if self.client_conn is not None:
+                self.client_conn.send(
+                    [
+                        0,
+                    ]
+                )
             self.server.terminate()
         if self.client_conn is not None:
             self.client_conn.close()
diff --git a/python/grass/temporal/c_libraries_interface.py b/python/grass/temporal/c_libraries_interface.py
index 0d24fc0f732..2b7f9f033f3 100644
--- a/python/grass/temporal/c_libraries_interface.py
+++ b/python/grass/temporal/c_libraries_interface.py
@@ -2,7 +2,7 @@
 Fast and exit-safe interface to GRASS C-library functions
 using ctypes and multiprocessing
 
-(C) 2013 by the GRASS Development Team
+(C) 2013-2024 by the GRASS Development Team
 This program is free software under the GNU General Public
 License (>=v2). Read the file COPYING that comes with GRASS
 for details.
@@ -10,11 +10,14 @@
 :authors: Soeren Gebbert
 """
 
+from __future__ import annotations
+
 import logging
 import sys
 from ctypes import CFUNCTYPE, POINTER, byref, c_int, c_void_p, cast
 from datetime import datetime
 from multiprocessing import Lock, Pipe, Process
+from typing import TYPE_CHECKING
 
 import grass.lib.date as libdate
 import grass.lib.gis as libgis
@@ -29,6 +32,10 @@
 from grass.pygrass.vector import VectorTopo
 from grass.script.utils import encode
 
+if TYPE_CHECKING:
+    from multiprocessing.connection import Connection
+    from multiprocessing.synchronize import _LockLike
+
 ###############################################################################
 
 
@@ -63,12 +70,13 @@ class RPCDefs:
 ###############################################################################
 
 
-def _read_map_full_info(lock, conn, data):
+def _read_map_full_info(lock: _LockLike, conn: Connection, data):
     """Read full map specific metadata from the spatial database using
     PyGRASS functions.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name, mapset]
     """
     info = None
@@ -190,7 +198,7 @@ def _read_vector_full_info(name, mapset, layer=None):
     return info
 
 
-def _fatal_error(lock, conn, data):
+def _fatal_error(lock: _LockLike, conn: Connection, data):
     """Calls G_fatal_error()"""
     libgis.G_fatal_error("Fatal Error in C library server")
 
@@ -198,11 +206,12 @@ def _fatal_error(lock, conn, data):
 ###############################################################################
 
 
-def _get_mapset(lock, conn, data):
+def _get_mapset(lock: _LockLike, conn: Connection, data):
     """Return the current mapset
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The mapset as list entry 1 [function_id]
 
     :returns: Name of the current mapset
@@ -214,11 +223,12 @@ def _get_mapset(lock, conn, data):
 ###############################################################################
 
 
-def _get_location(lock, conn, data):
+def _get_location(lock: _LockLike, conn: Connection, data):
     """Return the current location
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The mapset as list entry 1 [function_id]
 
     :returns: Name of the location
@@ -230,11 +240,12 @@ def _get_location(lock, conn, data):
 ###############################################################################
 
 
-def _get_gisdbase(lock, conn, data):
+def _get_gisdbase(lock: _LockLike, conn: Connection, data):
     """Return the current gisdatabase
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The mapset as list entry 1 [function_id]
 
     :returns: Name of the gisdatabase
@@ -246,11 +257,12 @@ def _get_gisdbase(lock, conn, data):
 ###############################################################################
 
 
-def _get_driver_name(lock, conn, data):
+def _get_driver_name(lock: _LockLike, conn: Connection, data):
     """Return the temporal database driver of a specific mapset
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The mapset as list entry 1 [function_id, mapset]
 
     :returns: Name of the driver or None if no temporal database present
@@ -264,11 +276,12 @@ def _get_driver_name(lock, conn, data):
 ###############################################################################
 
 
-def _get_database_name(lock, conn, data):
+def _get_database_name(lock: _LockLike, conn: Connection, data):
     """Return the temporal database name of a specific mapset
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The mapset as list entry 1 [function_id, mapset]
 
     :returns: Name of the database or None if no temporal database present
@@ -293,11 +306,12 @@ def _get_database_name(lock, conn, data):
 ###############################################################################
 
 
-def _available_mapsets(lock, conn, data):
+def _available_mapsets(lock: _LockLike, conn: Connection, data):
     """Return all available mapsets the user can access as a list of strings
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id]
 
     :returns: Names of available mapsets as list of strings
@@ -349,12 +363,13 @@ def _available_mapsets(lock, conn, data):
 ###############################################################################
 
 
-def _has_timestamp(lock, conn, data):
+def _has_timestamp(lock: _LockLike, conn: Connection, data):
     """Check if the file based GRASS timestamp is present and send
     True or False using the provided pipe.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name,
                  mapset, layer]
 
@@ -381,7 +396,7 @@ def _has_timestamp(lock, conn, data):
 ###############################################################################
 
 
-def _read_timestamp(lock, conn, data):
+def _read_timestamp(lock: _LockLike, conn: Connection, data):
     """Read the file based GRASS timestamp and send
     the result using the provided pipe.
 
@@ -401,7 +416,8 @@ def _read_timestamp(lock, conn, data):
     The end time may be None in case of a time instance.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send the result
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send the result
     :param data: The list of data entries [function_id, maptype, name,
                  mapset, layer]
 
@@ -429,7 +445,7 @@ def _read_timestamp(lock, conn, data):
 ###############################################################################
 
 
-def _write_timestamp(lock, conn, data):
+def _write_timestamp(lock: _LockLike, conn: Connection, data):
     """Write the file based GRASS timestamp
     the return values of the called C-functions using the provided pipe.
 
@@ -440,7 +456,8 @@ def _write_timestamp(lock, conn, data):
     values description.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name,
                  mapset, layer, timestring]
     """
@@ -473,7 +490,7 @@ def _write_timestamp(lock, conn, data):
 ###############################################################################
 
 
-def _remove_timestamp(lock, conn, data):
+def _remove_timestamp(lock: _LockLike, conn: Connection, data):
     """Remove the file based GRASS timestamp
     the return values of the called C-functions using the provided pipe.
 
@@ -484,7 +501,8 @@ def _remove_timestamp(lock, conn, data):
     values description.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name,
                  mapset, layer]
 
@@ -508,7 +526,7 @@ def _remove_timestamp(lock, conn, data):
 ###############################################################################
 
 
-def _read_semantic_label(lock, conn, data):
+def _read_semantic_label(lock: _LockLike, conn: Connection, data):
     """Read the file based GRASS band identifier
     the result using the provided pipe.
 
@@ -516,7 +534,8 @@ def _read_semantic_label(lock, conn, data):
     Rast_read_semantic_label: either a semantic label string or None.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name,
                  mapset, layer, timestring]
 
@@ -547,14 +566,15 @@ def _read_semantic_label(lock, conn, data):
 ###############################################################################
 
 
-def _write_semantic_label(lock, conn, data):
+def _write_semantic_label(lock: _LockLike, conn: Connection, data):
     """Write the file based GRASS band identifier.
 
     Rises ValueError on invalid semantic label.
     Always sends back True.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name,
                  mapset, layer, timestring]
 
@@ -583,13 +603,14 @@ def _write_semantic_label(lock, conn, data):
 ###############################################################################
 
 
-def _remove_semantic_label(lock, conn, data):
+def _remove_semantic_label(lock: _LockLike, conn: Connection, data):
     """Remove the file based GRASS band identifier.
 
     The value to be send via pipe is the return value of G_remove_misc.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name,
                  mapset, layer, timestring]
 
@@ -616,14 +637,15 @@ def _remove_semantic_label(lock, conn, data):
 ###############################################################################
 
 
-def _map_exists(lock, conn, data):
+def _map_exists(lock: _LockLike, conn: Connection, data):
     """Check if a map exists in the spatial database
 
     The value to be send via pipe is True in case the map exists and False
     if not.
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name, mapset]
 
     """
@@ -648,12 +670,13 @@ def _map_exists(lock, conn, data):
 ###############################################################################
 
 
-def _read_map_info(lock, conn, data):
+def _read_map_info(lock: _LockLike, conn: Connection, data):
     """Read map specific metadata from the spatial database using C-library
     functions
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name, mapset]
     """
     kvp = None
@@ -955,11 +978,12 @@ def _read_vector_info(name, mapset):
 ###############################################################################
 
 
-def _read_map_history(lock, conn, data):
+def _read_map_history(lock: _LockLike, conn: Connection, data):
     """Read map history from the spatial database using C-library functions
 
     :param lock: A multiprocessing.Lock instance
-    :param conn: A multiprocessing.Pipe instance used to send True or False
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe used to send True or False
     :param data: The list of data entries [function_id, maptype, name, mapset]
     """
     kvp = None
@@ -1174,7 +1198,7 @@ def _convert_timestamp_from_grass(ts):
 ###############################################################################
 
 
-def _stop(lock, conn, data):
+def _stop(lock: _LockLike, conn: Connection, data):
     libgis.G_debug(1, "Stop C-interface server")
     conn.close()
     lock.release()
@@ -1184,12 +1208,13 @@ def _stop(lock, conn, data):
 ###############################################################################
 
 
-def c_library_server(lock, conn):
+def c_library_server(lock: _LockLike, conn: Connection):
     """The GRASS C-libraries server function designed to be a target for
     multiprocessing.Process
 
     :param lock: A multiprocessing.Lock
-    :param conn: A multiprocessing.Pipe
+    :param conn: A multiprocessing.connection.Connection object obtained from
+                 multiprocessing.Pipe
     """
 
     def error_handler(data):
@@ -1239,9 +1264,8 @@ def error_handler(data):
         # Avoid busy waiting
         conn.poll(None)
         data = conn.recv()
-        lock.acquire()
-        functions[data[0]](lock, conn, data)
-        lock.release()
+        with lock:
+            functions[data[0]](lock, conn, data)
 
 
 class CLibrariesInterface(RPCServerBase):