Merge branch 'main' into docs/shift_origin

Author: seisman

pygmt/clib/session.py

@@ -87,6 +87,9 @@
     np.datetime64: "GMT_DATETIME",
 }
 
+# Load the GMT library outside the Session class to avoid repeated loading.
+_libgmt = load_libgmt()
+
 
 class Session:
     """
@@ -308,7 +311,7 @@ def get_libgmt_func(self, name, argtypes=None, restype=None):
         <class 'ctypes.CDLL.__init__.<locals>._FuncPtr'>
         """
         if not hasattr(self, "_libgmt"):
-            self._libgmt = load_libgmt()
+            self._libgmt = _libgmt
         function = getattr(self._libgmt, name)
         if argtypes is not None:
             function.argtypes = argtypes

pygmt/session_management.py

@@ -1,7 +1,11 @@
 """
 Modern mode session management modules.
 """
+import os
+import sys
+
 from pygmt.clib import Session
+from pygmt.helpers import unique_name
 
 
 def begin():
@@ -12,6 +16,10 @@ def begin():
 
     Only meant to be used once for creating the global session.
     """
+    # On Windows, need to set GMT_SESSION_NAME to a unique value
+    if sys.platform == "win32":
+        os.environ["GMT_SESSION_NAME"] = unique_name()
+
     prefix = "pygmt-session"
     with Session() as lib:
         lib.call_module(module="begin", args=prefix)

pygmt/tests/test_clib_loading.py

@@ -11,6 +11,7 @@
 
 import pytest
 from pygmt.clib.loading import check_libgmt, clib_full_names, clib_names, load_libgmt
+from pygmt.clib.session import Session
 from pygmt.exceptions import GMTCLibError, GMTCLibNotFoundError, GMTOSError
 
 
@@ -207,6 +208,44 @@ def test_brokenlib_brokenlib_workinglib(self):
         assert check_libgmt(load_libgmt(lib_fullnames=lib_fullnames)) is None
 
 
+class TestLibgmtCount:
+    """
+    Test that the GMT library is not repeatedly loaded in every session.
+    """
+
+    loaded_libgmt = load_libgmt()  # Load the GMT library and reuse it when necessary
+    counter = 0  # Global counter for how many times ctypes.CDLL is called
+
+    def _mock_ctypes_cdll_return(self, libname):  # noqa: ARG002
+        """
+        Mock ctypes.CDLL to count how many times the function is called.
+
+        If ctypes.CDLL is called, the counter increases by one.
+        """
+        self.counter += 1  # Increase the counter
+        return self.loaded_libgmt
+
+    def test_libgmt_load_counter(self, monkeypatch):
+        """
+        Make sure that the GMT library is not loaded in every session.
+        """
+        # Monkeypatch the ctypes.CDLL function
+        monkeypatch.setattr(ctypes, "CDLL", self._mock_ctypes_cdll_return)
+
+        # Create two sessions and check the global counter
+        with Session() as lib:
+            _ = lib
+        with Session() as lib:
+            _ = lib
+        assert self.counter == 0  # ctypes.CDLL is not called after two sessions.
+
+        # Explicitly calling load_libgmt to make sure the mock function is correct
+        load_libgmt()
+        assert self.counter == 1
+        load_libgmt()
+        assert self.counter == 2
+
+
 ###############################################################################
 # Test clib_full_names
 @pytest.fixture(scope="module", name="gmt_lib_names")

pygmt/tests/test_clib_virtualfiles.py

@@ -34,6 +34,19 @@ def fixture_dtypes():
     return "int8 int16 int32 int64 uint8 uint16 uint32 uint64 float32 float64".split()
 
 
+@pytest.fixture(scope="module", name="dtypes_pandas")
+def fixture_dtypes_pandas(dtypes):
+    """
+    List of supported pandas dtypes.
+    """
+    dtypes_pandas = dtypes.copy()
+
+    if find_spec("pyarrow") is not None:
+        dtypes_pandas.extend([f"{dtype}[pyarrow]" for dtype in dtypes_pandas])
+
+    return tuple(dtypes_pandas)
+
+
 def test_virtual_file(dtypes):
     """
     Test passing in data via a virtual file with a Dataset.
@@ -248,11 +261,10 @@ def test_virtualfile_from_vectors_two_string_or_object_columns(dtype):
         assert output == expected
 
 
-def test_virtualfile_from_vectors_transpose():
+def test_virtualfile_from_vectors_transpose(dtypes):
     """
     Test transforming matrix columns to virtual file dataset.
     """
-    dtypes = "float32 float64 int32 int64 uint32 uint64".split()
     shape = (7, 5)
     for dtype in dtypes:
         data = np.arange(shape[0] * shape[1], dtype=dtype).reshape(shape)
@@ -315,16 +327,14 @@ def test_virtualfile_from_matrix_slice(dtypes):
             assert output == expected
 
 
-def test_virtualfile_from_vectors_pandas(dtypes):
+def test_virtualfile_from_vectors_pandas(dtypes_pandas):
     """
     Pass vectors to a dataset using pandas.Series, checking both numpy and pyarrow
     dtypes.
     """
     size = 13
-    if find_spec("pyarrow") is not None:
-        dtypes.extend([f"{dtype}[pyarrow]" for dtype in dtypes])
 
-    for dtype in dtypes:
+    for dtype in dtypes_pandas:
         data = pd.DataFrame(
             data={
                 "x": np.arange(size),

pygmt/tests/test_session_management.py

@@ -1,7 +1,10 @@
 """
 Test the session management modules.
 """
+import multiprocessing as mp
 import os
+from importlib import reload
+from pathlib import Path
 
 import pytest
 from pygmt.clib import Session
@@ -57,3 +60,29 @@ def test_gmt_compat_6_is_applied(capsys):
         # Make sure no global "gmt.conf" in the current directory
         assert not os.path.exists("gmt.conf")
         begin()  # Restart the global session
+
+
+def _gmt_func_wrapper(figname):
+    """
+    A wrapper for running PyGMT scripts with multiprocessing.
+
+    Currently, we have to import pygmt and reload it in each process. Workaround from
+    https://github.com/GenericMappingTools/pygmt/issues/217#issuecomment-754774875.
+    """
+    import pygmt
+
+    reload(pygmt)
+    fig = pygmt.Figure()
+    fig.basemap(region=[10, 70, -3, 8], projection="X8c/6c", frame="afg")
+    fig.savefig(figname)
+
+
+def test_session_multiprocessing():
+    """
+    Make sure that multiprocessing is supported if pygmt is re-imported.
+    """
+    prefix = "test_session_multiprocessing"
+    with mp.Pool(2) as p:
+        p.map(_gmt_func_wrapper, [f"{prefix}-1.png", f"{prefix}-2.png"])
+    Path(f"{prefix}-1.png").unlink()
+    Path(f"{prefix}-2.png").unlink()