t.list: Add mapset options for t.list (#7631)

saket0187 · ninsbl · web-flow · commit dcb3324768fc · 2026-07-08T23:33:48.000+02:00
* Add mapset options for t.list

* do not require a TGIS DB in current mapset

---------

Co-authored-by: ninsbl &lt;stefan.blumentrath@gmx.de&gt;
diff --git a/python/grass/temporal/core.py b/python/grass/temporal/core.py
@@ -40,12 +40,14 @@
 from pathlib import Path
 
 import grass.script as gs
+from grass.tools import Tools
 from grass.pygrass import messages
 from grass.script.utils import decode
 
 from .c_libraries_interface import CLibrariesInterface
 
 
+tools = Tools()
 # Import all supported database backends (sqlite3 imported above)
 # Ignore import errors since they are checked later
 
@@ -497,21 +499,26 @@ def stop_subprocesses() -> None:
 atexit.register(stop_subprocesses)
 
 
-def get_available_temporal_mapsets():
-    """Return a list of of mapset names with temporal database driver and names
-    that are accessible from the current mapset.
+def get_available_temporal_mapsets(mapsets: str | None = None):
+    """Return a list of of mapset names with temporal database driver and names.
+
+    :param mapsets: A string specifying target mapsets ('.' for current, '*'
+                       for all mapsets in the location, or comma-separated names).
+                       If None, defaults to the current search path.
 
     :returns: A dictionary, mapset names are keys, the tuple (driver,
               database) are the values
     """
     global c_library_interface, message_interface
 
-    mapsets = c_library_interface.available_mapsets()
+    connections = tools.t_connect(flags="p", format="json", mapset=mapsets, quiet=True)
+    mapsets_list = [conn for conn in connections if all(conn.values())]
 
     tgis_mapsets = {}
 
-    for mapset in mapsets:
-        driver = c_library_interface.get_driver_name(mapset)
+    for mapset_data in mapsets_list:
+        mapset = mapset_data["mapset"]
+        driver = mapset_data["driver"]
         database = c_library_interface.get_database_name(mapset)
 
         message_interface.debug(
@@ -1098,8 +1105,8 @@ def _create_tgis_metadata_table(content, dbif=None) -> None:
 
 
 class SQLDatabaseInterfaceConnection:
-    def __init__(self) -> None:
-        self.tgis_mapsets = get_available_temporal_mapsets()
+    def __init__(self, mapsets: str | None = None) -> None:
+        self.tgis_mapsets = get_available_temporal_mapsets(mapsets)
         self.current_mapset = get_current_mapset()
         self.connections = {}
         self.connected = False
diff --git a/python/grass/temporal/list_stds.py b/python/grass/temporal/list_stds.py
@@ -25,16 +25,20 @@
 
 import grass.script as gs
 
-from .core import get_available_temporal_mapsets, get_tgis_message_interface, init_dbif
+from .core import get_tgis_message_interface, init_dbif
 from .datetime_math import time_delta_to_relative_time
-from .factory import dataset_factory
 from .open_stds import open_old_stds
 
 ###############################################################################
 
 
 def get_dataset_list(
-    type, temporal_type, columns=None, where=None, order=None, dbif=None
+    type,
+    temporal_type,
+    columns=None,
+    where=None,
+    order=None,
+    dbif=None,
 ):
     """Return a list of time stamped maps or space time datasets of a specific
     temporal type that are registered in the temporal database
@@ -93,20 +97,15 @@ def get_dataset_list(
         >>> check = sp.delete()
 
     """
-    id = None
-    sp = dataset_factory(type, id)
-
     dbif, connection_state_changed = init_dbif(dbif)
 
-    mapsets = get_available_temporal_mapsets()
-
     result = {}
 
-    for mapset in mapsets.keys():
+    for mapset in dbif.tgis_mapsets:
         if temporal_type == "absolute":
-            table = sp.get_type() + "_view_abs_time"
+            table = type + "_view_abs_time"
         else:
-            table = sp.get_type() + "_view_rel_time"
+            table = type + "_view_rel_time"
 
         if columns and columns.find("all") == -1:
             sql = "SELECT " + str(columns) + " FROM " + table
diff --git a/temporal/t.list/t.list.md b/temporal/t.list/t.list.md
@@ -17,13 +17,22 @@ The SQL *where* and *sort* expression will be applied for each temporal
 database that was found in accessible mapsets. Hence sorting works only
 on mapset basis.
 
-Temporal databases stored in other mapsets can be used as long as they
-are in the user's current mapset search path (managed with
-[g.mapsets](g.mapsets.md)).
+The **mapset** option allows the user to filter the output to one
+or multiple specific mapsets, or to query all mapsets in the project regardless
+of the current search path. By default (if the **mapset** option is not provided),
+Temporal datasets are listed from all mapsets in the user's current search path
+(managed with [g.mapsets](g.mapsets.md)).
+
+The **mapset** parameter accepts the following inputs:
+`mapset='.'` lists datasets only in the current mapset.
+`mapset='*'` lists datasets in all mapsets in the project (location), bypassing
+the search path.
+`mapset=name1,name2` lists datasets strictly from the explicitly named mapsets,
+even if they are outside the current search path.
 
 ## EXAMPLES
 
-Obtain the list of space time raster dataset(s):
+Obtain the list of space time raster dataset(s) in the current search path:
 
 ```sh
 t.list strds
@@ -32,6 +41,30 @@ Space time raster datasets with absolute time available in mapset <climate_2000_
 tempmean_monthly@climate_2000_2012
 ```
 
+Obtain the list of space time raster datasets in a specific mapset, even if it is
+not in the search path:
+
+```sh
+t.list strds mapset=modis2002lst
+----------------------------------------------
+Space time raster datasets with absolute time available in mapset <modis2002lst>:
+mini_set@modis2002lst
+```
+
+Obtain the list of space time raster datasets across all mapsets in the project
+(location) using '*':
+
+```sh
+t.list type=strds mapset='*'
+----------------------------------------------
+Space time raster datasets with absolute time available in mapset <climate_2000_2012>:
+precip_abs@climate_2000_2012
+precipitation@climate_2000_2012
+tempmean@climate_2000_2012
+Space time raster datasets with absolute time available in mapset <modis2002lst>:
+mini_set@modis2002lst
+```
+
 Obtain the list of space time raster datasets in a specific mapset (Note
 that the target mapset must be in the user's search path):
 
diff --git a/temporal/t.list/t.list.py b/temporal/t.list/t.list.py
@@ -78,6 +78,12 @@
 # % guisection: Formatting
 # %end
 
+# %option G_OPT_M_MAPSET
+# % multiple: yes
+# % description: Name of mapsets to list ('.' for current, '*' for all mapsets)
+# % guisection: Selection
+# %end
+
 # %option G_OPT_F_SEP
 # % answer:
 # % label: Field separator character between the output columns
@@ -99,15 +105,14 @@
 from contextlib import nullcontext
 
 import grass.script as gs
-from grass.tools import Tools
 
 ############################################################################
 
 
 def main():
 
     # Get the options
-    type = options["type"]
+    stds_type = options["type"]
     temporal_type = options["temporaltype"]
     columns = options["columns"]
     order = options["order"]
@@ -116,6 +121,7 @@ def main():
     outpath = options["output"]
     colhead = flags["c"]
     output_format = options.get("format", "plain")
+    mapsets = options["mapset"]
 
     if not columns:
         columns = "all" if output_format == "json" else "id"
@@ -150,17 +156,20 @@ def main():
     elif not separator:  # output_format == "plain"
         separator = "|"
 
-    tools = Tools()
+    # Lazy import and initialize TGIS
+    import grass.temporal as tgis
 
-    conn = tools.t_connect(flags="p", format="json", mapset=".")
+    tgis.init(skip_db_init=True)
 
-    db_exists = conn[0]["driver"] and conn[0]["database"]
+    dbif = tgis.SQLDatabaseInterfaceConnection(mapsets=mapsets)
 
     # if no connection is found
-    if not db_exists:
+    if not dbif.tgis_mapsets:
         if output_format == "plain":
             gs.message(
-                _("No temporal database exists in this mapset. No datasets to list.")
+                _(
+                    "No temporal database found in the requested mapset(s). No datasets to list."
+                )
             )
         with (
             open(outpath, "w")
@@ -171,19 +180,11 @@ def main():
                 out_file.write(json.dumps([], indent=4) + "\n")
         return
 
-    # Lazy import
-    import grass.temporal as tgis
-
-    # Make sure the temporal database exists
-    tgis.init()
-
-    sp = tgis.dataset_factory(type, None)
-    dbif = tgis.SQLDatabaseInterfaceConnection()
     dbif.connect()
-    first = True
 
     json_output = []
     line_output = []
+    first = True
 
     if gs.verbosity() > 0 and not outpath and output_format == "plain":
         sys.stderr.write("----------------------------------------------\n")
@@ -196,80 +197,73 @@ def main():
     ):
         for ttype in temporal_type.split(","):
             time = "absolute time" if ttype == "absolute" else "relative time"
-
             stds_list = tgis.get_dataset_list(
-                type, ttype, columns, where, order, dbif=dbif
+                stds_type, ttype, columns, where, order, dbif=dbif
             )
 
-            mapsets = tgis.get_tgis_c_library_interface().available_mapsets()
-
-            for key in mapsets:
-                if key in stds_list.keys():
-                    rows = stds_list[key]
-
-                    if rows:
-                        if (
-                            gs.verbosity() > 0
-                            and (not outpath or outpath == "-")
-                            and output_format == "plain"
-                        ):
-                            if issubclass(sp.__class__, tgis.AbstractMapDataset):
-                                sys.stderr.write(
-                                    _(
-                                        "Time stamped %s maps with %s available in mapset "
-                                        "<%s>:\n"
-                                    )
-                                    % (sp.get_type(), time, key)
-                                )
-                            else:
-                                sys.stderr.write(
-                                    _(
-                                        "Space time %s datasets with %s available in "
-                                        "mapset <%s>:\n"
-                                    )
-                                    % (
-                                        sp.get_new_map_instance(None).get_type(),
-                                        time,
-                                        key,
-                                    )
+            for mapset in dbif.tgis_mapsets:
+                rows = stds_list.get(mapset)
+                if rows:
+                    if (
+                        gs.verbosity() > 0
+                        and (not outpath or outpath == "-")
+                        and output_format == "plain"
+                    ):
+                        if stds_type in {"raster", "raster_3d", "vector"}:
+                            sys.stderr.write(
+                                _(
+                                    "Time stamped %s maps with %s available in mapset "
+                                    "<%s>:\n"
                                 )
-
-                        if output_format == "json":
-                            for row in rows:
-                                json_output.append(dict(row))
-
-                        elif output_format == "line":
-                            line_output.extend([str(row[0]) for row in rows])
-
+                                % (stds_type, time, mapset)
+                            )
                         else:
-                            if (colhead or output_format == "csv") and first:
-                                output = ""
-                                count = 0
-                                for col_key in rows[0].keys():
-                                    output += (separator if count > 0 else "") + str(
-                                        col_key
+                            sys.stderr.write(
+                                _(
+                                    "Space time %s datasets with %s available in "
+                                    "mapset <%s>:\n"
+                                )
+                                % (
+                                    stds_type,
+                                    time,
+                                    mapset,
+                                )
+                            )
+
+                    if output_format == "json":
+                        for row in rows:
+                            json_output.append(dict(row))
+
+                    elif output_format == "line":
+                        line_output.extend([str(row[0]) for row in rows])
+
+                    else:
+                        if (colhead or output_format == "csv") and first:
+                            output = ""
+                            count = 0
+                            for col_key in rows[0].keys():
+                                output += (separator if count > 0 else "") + str(
+                                    col_key
+                                )
+                                count += 1
+                            out_file.write(f"{output}\n")
+                            first = False
+
+                        for row in rows:
+                            output = ""
+                            count = 0
+                            for col in row:
+                                # If the database value is None, make it an empty string for csv
+                                if col is None:
+                                    cell_value = (
+                                        "" if output_format == "csv" else "None"
                                     )
-                                    count += 1
-                                out_file.write("{st}\n".format(st=output))
-                                first = False
-
-                            for row in rows:
-                                output = ""
-                                count = 0
-                                for col in row:
-                                    # If the database value is None, make it an empty string for csv
-                                    if col is None:
-                                        cell_value = (
-                                            "" if output_format == "csv" else "None"
-                                        )
-                                    else:
-                                        cell_value = str(col)
-
-                                    output += (
-                                        separator if count > 0 else ""
-                                    ) + cell_value
-                                    count += 1
-                                out_file.write("{st}\n".format(st=output))
+                                else:
+                                    cell_value = str(col)
+
+                                output += (separator if count > 0 else "") + cell_value
+                                count += 1
+                            out_file.write("{st}\n".format(st=output))
 
         # Dump the collected JSON and line data
         if output_format == "json":
diff --git a/temporal/t.list/tests/conftest.py b/temporal/t.list/tests/conftest.py
diff --git a/temporal/t.list/tests/test_t_list.py b/temporal/t.list/tests/test_t_list.py
