ngiab-data-preprocess 4.2.0__py3-none-any.whl → 4.2.2__py3-none-any.whl

data_processing/create_realization.py

@@ -1,29 +1,30 @@
 import json
+import logging
 import multiprocessing
+import shutil
 import sqlite3
+from collections import defaultdict
 from datetime import datetime
 from pathlib import Path
-import shutil
-import requests
 
 import pandas
+import requests
 import s3fs
 import xarray as xr
-import logging
-from collections import defaultdict
 from dask.distributed import Client, LocalCluster
 from data_processing.file_paths import file_paths
 from data_processing.gpkg_utils import (
     GeoPackage,
+    get_cat_to_nex_flowpairs,
     get_cat_to_nhd_feature_id,
     get_table_crs_short,
-    get_cat_to_nex_flowpairs,
 )
-from tqdm.rich import tqdm
 from pyproj import Transformer
+from tqdm.rich import tqdm
 
 logger = logging.getLogger(__name__)
 
+
 def get_approximate_gw_storage(paths: file_paths, start_date: datetime):
     # get the gw levels from the NWM output on a given start date
     # this kind of works in place of warmstates for now
@@ -78,7 +79,9 @@ def make_cfe_config(
             slope=row["mean.slope_1km"],
             smcmax=row["mean.smcmax_soil_layers_stag=2"],
             smcwlt=row["mean.smcwlt_soil_layers_stag=2"],
-            max_gw_storage=row["mean.Zmax"]/1000 if row["mean.Zmax"] is not None else "0.011[m]", # mean.Zmax is in mm!
+            max_gw_storage=row["mean.Zmax"] / 1000
+            if row["mean.Zmax"] is not None
+            else "0.011[m]",  # mean.Zmax is in mm!
             gw_Coeff=row["mean.Coeff"] if row["mean.Coeff"] is not None else "0.0018[m h-1]",
             gw_Expon=row["mode.Expon"],
             gw_storage="{:.5}".format(gw_storage_ratio),
@@ -92,7 +95,6 @@ def make_cfe_config(
 def make_noahowp_config(
     base_dir: Path, divide_conf_df: pandas.DataFrame, start_time: datetime, end_time: datetime
 ) -> None:
-
     divide_conf_df.set_index("divide_id", inplace=True)
     start_datetime = start_time.strftime("%Y%m%d%H%M")
     end_datetime = end_time.strftime("%Y%m%d%H%M")
@@ -110,8 +112,8 @@ def make_noahowp_config(
                     end_datetime=end_datetime,
                     lat=divide_conf_df.loc[divide, "latitude"],
                     lon=divide_conf_df.loc[divide, "longitude"],
-                    terrain_slope= divide_conf_df.loc[divide, "mean.slope_1km"],
-                    azimuth= divide_conf_df.loc[divide, "circ_mean.aspect"],
+                    terrain_slope=divide_conf_df.loc[divide, "mean.slope_1km"],
+                    azimuth=divide_conf_df.loc[divide, "circ_mean.aspect"],
                     ISLTYP=int(divide_conf_df.loc[divide, "mode.ISLTYP"]),
                     IVGTYP=int(divide_conf_df.loc[divide, "mode.IVGTYP"]),
                 )
@@ -182,6 +184,7 @@ def get_model_attributes_pyproj(hydrofabric: Path):
 
     return divide_conf_df
 
+
 def get_model_attributes(hydrofabric: Path):
     try:
         with GeoPackage(hydrofabric) as conn:
@@ -205,30 +208,31 @@ def get_model_attributes(hydrofabric: Path):
             )
     except sqlite3.OperationalError:
         with sqlite3.connect(hydrofabric) as conn:
-            conf_df = pandas.read_sql_query("SELECT* FROM 'divide-attributes';", conn,)
+            conf_df = pandas.read_sql_query(
+                "SELECT* FROM 'divide-attributes';",
+                conn,
+            )
         source_crs = get_table_crs_short(hydrofabric, "divides")
         transformer = Transformer.from_crs(source_crs, "EPSG:4326", always_xy=True)
-        lon, lat = transformer.transform(
-            conf_df["centroid_x"].values, conf_df["centroid_y"].values
-        )
+        lon, lat = transformer.transform(conf_df["centroid_x"].values, conf_df["centroid_y"].values)
         conf_df["longitude"] = lon
         conf_df["latitude"] = lat
 
         conf_df.drop(columns=["centroid_x", "centroid_y"], axis=1, inplace=True)
     return conf_df
 
+
 def make_em_config(
     hydrofabric: Path,
     output_dir: Path,
     template_path: Path = file_paths.template_em_config,
 ):
-
     # test if modspatialite is available
     try:
         divide_conf_df = get_model_attributes_modspatialite(hydrofabric)
     except Exception as e:
         logger.warning(f"mod_spatialite not available, using pyproj instead: {e}")
-        logger.warning(f"Install mod_spatialite for improved performance")
+        logger.warning("Install mod_spatialite for improved performance")
         divide_conf_df = get_model_attributes_pyproj(hydrofabric)
 
     cat_config_dir = output_dir / "cat_config" / "empirical_model"
@@ -256,7 +260,6 @@ def make_em_config(
 def configure_troute(
     cat_id: str, config_dir: Path, start_time: datetime, end_time: datetime
 ) -> int:
-
     with open(file_paths.template_troute_config, "r") as file:
         troute_template = file.read()
     time_step_size = 300
@@ -269,7 +272,7 @@ def configure_troute(
         geo_file_path=f"./config/{cat_id}_subset.gpkg",
         start_datetime=start_time.strftime("%Y-%m-%d %H:%M:%S"),
         nts=nts,
-        max_loop_size=nts,        
+        max_loop_size=nts,
     )
 
     with open(config_dir / "troute.yaml", "w") as file:
@@ -301,9 +304,7 @@ def create_em_realization(cat_id: str, start_time: datetime, end_time: datetime)
         f.write(em_config)
 
     configure_troute(cat_id, paths.config_dir, start_time, end_time)
-    make_ngen_realization_json(
-        paths.config_dir, template_path, start_time, end_time
-    )
+    make_ngen_realization_json(paths.config_dir, template_path, start_time, end_time)
     make_em_config(paths.geopackage_path, paths.config_dir)
     # create some partitions for parallelization
     paths.setup_run_folders()
@@ -324,15 +325,14 @@ def create_realization(
     if gage_id is not None:
         # try and download s3:communityhydrofabric/hydrofabrics/community/gage_parameters/gage_id
         # if it doesn't exist, use the default
-        try:
-            url = f"https://communityhydrofabric.s3.us-east-1.amazonaws.com/hydrofabrics/community/gage_parameters/{gage_id}.json"
-
+        url = f"https://communityhydrofabric.s3.us-east-1.amazonaws.com/hydrofabrics/community/gage_parameters/{gage_id}.json"
+        response = requests.get(url)
+        if response.status_code == 200:
             new_template = requests.get(url).json()
-            template_path = paths.config_dir / "calibrated_params.json"
+            template_path = paths.config_dir / "downloaded_params.json"
             with open(template_path, "w") as f:
                 json.dump(new_template, f)
-        except Exception as e:
-            logger.warning(f"Failed to download gage parameters")
+            logger.info(f"downloaded calibrated parameters for {gage_id}")
 
     conf_df = get_model_attributes(paths.geopackage_path)
 
@@ -347,9 +347,7 @@ def create_realization(
 
     configure_troute(cat_id, paths.config_dir, start_time, end_time)
 
-    make_ngen_realization_json(
-        paths.config_dir, template_path, start_time, end_time
-    )
+    make_ngen_realization_json(paths.config_dir, template_path, start_time, end_time)
 
     # create some partitions for parallelization
     paths.setup_run_folders()

data_processing/forcings.py

@@ -3,32 +3,29 @@ import multiprocessing
 import os
 import time
 import warnings
-from datetime import datetime
 from functools import partial
 from math import ceil
 from multiprocessing import shared_memory
 from pathlib import Path
-
-from dask.distributed import Client, LocalCluster
+from typing import Tuple
 
 import geopandas as gpd
 import numpy as np
 import pandas as pd
 import psutil
 import xarray as xr
-from data_processing.file_paths import file_paths
+from dask.distributed import Client, LocalCluster
 from data_processing.dataset_utils import validate_dataset_format
+from data_processing.file_paths import file_paths
 from exactextract import exact_extract
 from exactextract.raster import NumPyRasterSource
 from rich.progress import (
-    Progress,
     BarColumn,
+    Progress,
     TextColumn,
     TimeElapsedColumn,
     TimeRemainingColumn,
 )
-from typing import Tuple
-
 
 logger = logging.getLogger(__name__)
 # Suppress the specific warning from numpy to keep the cli output clean
@@ -40,13 +37,13 @@ warnings.filterwarnings(
 )
 
 
-def weighted_sum_of_cells(flat_raster: np.ndarray, 
-                          cell_ids: np.ndarray, 
-                          factors: np.ndarray) -> np.ndarray:
-    '''  
+def weighted_sum_of_cells(
+    flat_raster: np.ndarray, cell_ids: np.ndarray, factors: np.ndarray
+) -> np.ndarray:
+    """
     Take an average of each forcing variable in a catchment. Create an output
-    array initialized with zeros, and then sum up the forcing variable and 
-    divide by the sum of the cell weights to get an averaged forcing variable 
+    array initialized with zeros, and then sum up the forcing variable and
+    divide by the sum of the cell weights to get an averaged forcing variable
     for the entire catchment.
 
     Parameters
@@ -65,7 +62,7 @@ def weighted_sum_of_cells(flat_raster: np.ndarray,
         An one-dimensional array, where each element corresponds to a timestep.
         Each element contains the averaged forcing value for the whole catchment
         over one timestep.
-    '''
+    """
     result = np.zeros(flat_raster.shape[0])
     result = np.sum(flat_raster[:, cell_ids] * factors, axis=1)
     sum_of_weights = np.sum(factors)
@@ -73,12 +70,10 @@ def weighted_sum_of_cells(flat_raster: np.ndarray,
     return result
 
 
-def get_cell_weights(raster: xr.Dataset, 
-                     gdf: gpd.GeoDataFrame, 
-                     wkt: str) -> pd.DataFrame:
-    '''
-    Get the cell weights (coverage) for each cell in a divide. Coverage is 
-    defined as the fraction (a float in [0,1]) of a raster cell that overlaps 
+def get_cell_weights(raster: xr.Dataset, gdf: gpd.GeoDataFrame, wkt: str) -> pd.DataFrame:
+    """
+    Get the cell weights (coverage) for each cell in a divide. Coverage is
+    defined as the fraction (a float in [0,1]) of a raster cell that overlaps
     with the polygon in the passed gdf.
 
     Parameters
@@ -96,7 +91,7 @@ def get_cell_weights(raster: xr.Dataset,
     pd.DataFrame
         DataFrame indexed by divide_id that contains information about coverage
         for each raster cell in gridded forcing file.
-    '''
+    """
     xmin = raster.x[0]
     xmax = raster.x[-1]
     ymin = raster.y[0]
@@ -116,15 +111,17 @@ def get_cell_weights(raster: xr.Dataset,
 
 
 def add_APCP_SURFACE_to_dataset(dataset: xr.Dataset) -> xr.Dataset:
-    '''Convert precipitation value to correct units.'''
+    """Convert precipitation value to correct units."""
     # precip_rate is mm/s
     # cfe says input atmosphere_water__liquid_equivalent_precipitation_rate is mm/h
     # nom says prcpnonc input is mm/s
     # technically should be kg/m^2/s at 1kg = 1l it equates to mm/s
     # nom says qinsur output is m/s, hopefully qinsur is converted to mm/h by ngen
     dataset["APCP_surface"] = dataset["precip_rate"] * 3600
-    dataset["APCP_surface"].attrs["units"] = "mm h^-1" # ^-1 notation copied from source data
-    dataset["APCP_surface"].attrs["source_note"] = "This is just the precip_rate variable converted to mm/h by multiplying by 3600"
+    dataset["APCP_surface"].attrs["units"] = "mm h^-1"  # ^-1 notation copied from source data
+    dataset["APCP_surface"].attrs["source_note"] = (
+        "This is just the precip_rate variable converted to mm/h by multiplying by 3600"
+    )
     return dataset
 
 
@@ -132,14 +129,14 @@ def add_precip_rate_to_dataset(dataset: xr.Dataset) -> xr.Dataset:
     # the inverse of the function above
     dataset["precip_rate"] = dataset["APCP_surface"] / 3600
     dataset["precip_rate"].attrs["units"] = "mm s^-1"
-    dataset["precip_rate"].attrs[
-        "source_note"
-    ] = "This is just the APCP_surface variable converted to mm/s by dividing by 3600"
+    dataset["precip_rate"].attrs["source_note"] = (
+        "This is just the APCP_surface variable converted to mm/s by dividing by 3600"
+    )
     return dataset
 
 
 def get_index_chunks(data: xr.DataArray) -> list[tuple[int, int]]:
-    '''  
+    """
     Take a DataArray and calculate the start and end index for each chunk based
     on the available memory.
 
@@ -153,7 +150,7 @@ def get_index_chunks(data: xr.DataArray) -> list[tuple[int, int]]:
     list[Tuple[int, int]]
         Each element in the list represents a chunk of data. The tuple within
         the chunk indicates the start index and end index of the chunk.
-    '''
+    """
     array_memory_usage = data.nbytes
     free_memory = psutil.virtual_memory().available * 0.8  # 80% of available memory
     # limit the chunk to 20gb, makes things more stable
@@ -166,15 +163,13 @@ def get_index_chunks(data: xr.DataArray) -> list[tuple[int, int]]:
     return index_chunks
 
 
-def create_shared_memory(lazy_array: xr.Dataset) -> Tuple[
-    shared_memory.SharedMemory,
-    np.dtype,
-    np.dtype
-]:
-    '''
-    Create a shared memory object so that multiple processes can access loaded 
+def create_shared_memory(
+    lazy_array: xr.Dataset,
+) -> Tuple[shared_memory.SharedMemory, np.dtype, np.dtype]:
+    """
+    Create a shared memory object so that multiple processes can access loaded
     data.
-    
+
     Parameters
     ----------
     lazy_array : xr.Dataset
@@ -183,22 +178,22 @@ def create_shared_memory(lazy_array: xr.Dataset) -> Tuple[
     Returns
     -------
     shared_memory.SharedMemory
-        A specific block of memory allocated by the OS of the size of 
+        A specific block of memory allocated by the OS of the size of
         lazy_array.
     np.dtype.shape
         A shape object with dimensions (# timesteps, # of raster cells) in
         reference to lazy_array.
     np.dtype
         Data type of objects in lazy_array.
-    '''
-    logger.debug(f"Creating shared memory size {lazy_array.nbytes/ 10**6} Mb.")
+    """
+    logger.debug(f"Creating shared memory size {lazy_array.nbytes / 10**6} Mb.")
     shm = shared_memory.SharedMemory(create=True, size=lazy_array.nbytes)
     shared_array = np.ndarray(lazy_array.shape, dtype=np.float32, buffer=shm.buf)
     # if your data is not float32, xarray will do an automatic conversion here
     # which consumes a lot more memory, forcings downloaded with this tool will work
     for start, end in get_index_chunks(lazy_array):
-            # copy data from lazy to shared memory one chunk at a time
-            shared_array[start:end] = lazy_array[start:end]
+        # copy data from lazy to shared memory one chunk at a time
+        shared_array[start:end] = lazy_array[start:end]
 
     time, x, y = shared_array.shape
     shared_array = shared_array.reshape(time, -1)
@@ -206,14 +201,16 @@ def create_shared_memory(lazy_array: xr.Dataset) -> Tuple[
     return shm, shared_array.shape, shared_array.dtype
 
 
-def process_chunk_shared(variable: str,
-                         times: np.ndarray,
-                         shm_name: str,
-                         shape: np.dtype.shape,
-                         dtype: np.dtype, 
-                         chunk: gpd.GeoDataFrame) -> xr.DataArray:
-    '''  
-    Process the gridded forcings chunk loaded into a SharedMemory block. 
+def process_chunk_shared(
+    variable: str,
+    times: np.ndarray,
+    shm_name: str,
+    shape: np.dtype.shape,
+    dtype: np.dtype,
+    chunk: gpd.GeoDataFrame,
+) -> xr.DataArray:
+    """
+    Process the gridded forcings chunk loaded into a SharedMemory block.
 
     Parameters
     ----------
@@ -235,7 +232,7 @@ def process_chunk_shared(variable: str,
     -------
     xr.DataArray
         Averaged forcings data for each timestep for each catchment.
-    '''
+    """
     existing_shm = shared_memory.SharedMemory(name=shm_name)
     raster = np.ndarray(shape, dtype=dtype, buffer=existing_shm.buf)
     results = []
@@ -256,10 +253,10 @@ def process_chunk_shared(variable: str,
     return xr.concat(results, dim="catchment")
 
 
-def get_cell_weights_parallel(gdf: gpd.GeoDataFrame,
-                              input_forcings: xr.Dataset,
-                              num_partitions: int) -> pd.DataFrame:
-    '''
+def get_cell_weights_parallel(
+    gdf: gpd.GeoDataFrame, input_forcings: xr.Dataset, num_partitions: int
+) -> pd.DataFrame:
+    """
     Execute get_cell_weights with multiprocessing, with chunking for the passed
     GeoDataFrame to conserve memory usage.
 
@@ -277,7 +274,7 @@ def get_cell_weights_parallel(gdf: gpd.GeoDataFrame,
     pd.DataFrame
         DataFrame indexed by divide_id that contains information about coverage
         for each raster cell and each timestep in gridded forcing file.
-    '''
+    """
     gdf_chunks = np.array_split(gdf, num_partitions)
     wkt = gdf.crs.to_wkt()
     one_timestep = input_forcings.isel(time=0).compute()
@@ -286,20 +283,21 @@ def get_cell_weights_parallel(gdf: gpd.GeoDataFrame,
         catchments = pool.starmap(get_cell_weights, args)
     return pd.concat(catchments)
 
+
 def get_units(dataset: xr.Dataset) -> dict:
-    '''
+    """
     Return dictionary of units for each variable in dataset.
-    
+
     Parameters
     ----------
     dataset : xr.Dataset
         Dataset with variables and units.
-    
+
     Returns
     -------
-    dict 
+    dict
         {variable name: unit}
-    '''
+    """
     units = {}
     for var in dataset.data_vars:
         if dataset[var].attrs["units"]:
@@ -310,9 +308,9 @@ def get_units(dataset: xr.Dataset) -> dict:
 def compute_zonal_stats(
     gdf: gpd.GeoDataFrame, gridded_data: xr.Dataset, forcings_dir: Path
 ) -> None:
-    '''  
-    Compute zonal statistics in parallel for all timesteps over all desired 
-    catchments. Create chunks of catchments and within those, chunks of 
+    """
+    Compute zonal statistics in parallel for all timesteps over all desired
+    catchments. Create chunks of catchments and within those, chunks of
     timesteps for memory management.
 
     Parameters
@@ -323,7 +321,7 @@ def compute_zonal_stats(
         Gridded forcing data that intersects with desired catchments.
     forcings_dir : Path
         Path to directory where outputs are to be stored.
-    '''
+    """
     logger.info("Computing zonal stats in parallel for all timesteps")
     timer_start = time.time()
     num_partitions = multiprocessing.cpu_count() - 1
@@ -414,7 +412,7 @@ def compute_zonal_stats(
 
 
 def write_outputs(forcings_dir: Path, units: dict) -> None:
-    '''  
+    """
     Write outputs to disk in the form of a NetCDF file, using dask clusters to
     facilitate parallel computing.
 
@@ -423,13 +421,13 @@ def write_outputs(forcings_dir: Path, units: dict) -> None:
     forcings_dir : Path
         Path to directory where outputs are to be stored.
     variables : dict
-        Preset dictionary where the keys are forcing variable names and the 
+        Preset dictionary where the keys are forcing variable names and the
         values are units.
     units : dict
-        Dictionary where the keys are forcing variable names and the values are 
+        Dictionary where the keys are forcing variable names and the values are
         units. Differs from variables, as this dictionary depends on the gridded
         forcing dataset.
-    '''
+    """
 
     # start a dask cluster if there isn't one already running
     try:
@@ -508,7 +506,7 @@ def setup_directories(cat_id: str) -> file_paths:
 def create_forcings(dataset: xr.Dataset, output_folder_name: str) -> None:
     validate_dataset_format(dataset)
     forcing_paths = setup_directories(output_folder_name)
-    print(f"forcing path {output_folder_name} {forcing_paths.forcings_dir}")
+    logger.debug(f"forcing path {output_folder_name} {forcing_paths.forcings_dir}")
     gdf = gpd.read_file(forcing_paths.geopackage_path, layer="divides")
     logger.debug(f"gdf  bounds: {gdf.total_bounds}")
     gdf = gdf.to_crs(dataset.crs)

data_processing/gpkg_utils.py

@@ -290,6 +290,7 @@ def update_geopackage_metadata(gpkg: Path) -> None:
 
     con.close()
 
+
 def subset_table_by_vpu(table: str, vpu: str, hydrofabric: Path, subset_gpkg_name: Path) -> None:
     """
     Subset the specified table from the hydrofabric database by vpuid and save it to the subset geopackage.
@@ -306,9 +307,9 @@ def subset_table_by_vpu(table: str, vpu: str, hydrofabric: Path, subset_gpkg_nam
     dest_db = sqlite3.connect(subset_gpkg_name)
 
     if vpu == "03":
-        vpus = ["03N","03S","03W"]
+        vpus = ["03N", "03S", "03W"]
     elif vpu == "10":
-        vpus = ["10L","10U"]
+        vpus = ["10L", "10U"]
     else:
         vpus = [vpu]
 
@@ -320,22 +321,21 @@ def subset_table_by_vpu(table: str, vpu: str, hydrofabric: Path, subset_gpkg_nam
     if table == "network":
         # Look for the network entry that has a toid not in the flowpath or nexus tables
         network_toids = [x[2] for x in contents]
-        print(f"Network toids: {len(network_toids)}")
+        logger.debug(f"Network toids: {len(network_toids)}")
         sql = "SELECT id FROM flowpaths"
         flowpath_ids = [x[0] for x in dest_db.execute(sql).fetchall()]
-        print(f"Flowpath ids: {len(flowpath_ids)}")
+        logger.debug(f"Flowpath ids: {len(flowpath_ids)}")
         sql = "SELECT id FROM nexus"
         nexus_ids = [x[0] for x in dest_db.execute(sql).fetchall()]
-        print(f"Nexus ids: {len(nexus_ids)}")
+        logger.debug(f"Nexus ids: {len(nexus_ids)}")
         bad_ids = set(network_toids) - set(flowpath_ids + nexus_ids)
-        print(bad_ids)
-        print(f"Removing {len(bad_ids)} network entries that are not in flowpaths or nexuses")
+        logger.debug(bad_ids)
+        logger.info(f"Removing {len(bad_ids)} network entries that are not in flowpaths or nexuses")
         # id column is second after fid
         contents = [x for x in contents if x[1] not in bad_ids]
 
     insert_data(dest_db, table, contents)
 
-
     if table in get_feature_tables(file_paths.conus_hydrofabric):
         fids = [str(x[0]) for x in contents]
         copy_rTree_tables(table, fids, source_db, dest_db)
@@ -372,6 +372,14 @@ def subset_table(table: str, ids: List[str], hydrofabric: Path, subset_gpkg_name
         sql_query = "SELECT divide_id FROM 'divides'"
         contents = dest_db.execute(sql_query).fetchall()
         ids = [str(x[0]) for x in contents]
+
+    if table == "nexus":
+        # add the nexuses in the toid column from the flowpaths table
+        sql_query = "SELECT toid FROM 'flowpaths'"
+        contents = dest_db.execute(sql_query).fetchall()
+        new_ids = [str(x[0]) for x in contents]
+        ids.extend(new_ids)
+
     ids = [f"'{x}'" for x in ids]
     key_name = "id"
     if table in table_keys:
@@ -409,6 +417,7 @@ def get_table_crs_short(gpkg: str, table: str) -> str:
         crs = con.execute(sql_query).fetchone()[0]
     return crs
 
+
 def get_table_crs(gpkg: str, table: str) -> str:
     """
     Get the CRS of the specified table in the specified geopackage.
@@ -510,7 +519,6 @@ def get_available_tables(gpkg: Path) -> List[str]:
 
 
 def get_cat_to_nhd_feature_id(gpkg: Path = file_paths.conus_hydrofabric) -> dict:
-
     available_tables = get_available_tables(gpkg)
     possible_tables = ["flowpath_edge_list", "network"]
 

data_processing/subset.py

@@ -22,7 +22,7 @@ subset_tables = [
     "flowpath-attributes-ml",
     "flowpaths",
     "hydrolocations",
-    "nexus",
+    "nexus",  # depends on flowpaths in some cases e.g. gage delineation
     "pois",  # requires flowpaths
     "lakes",  # requires pois
     "network",
@@ -52,8 +52,9 @@ def create_subset_gpkg(
     update_geopackage_metadata(output_gpkg_path)
 
 
-def subset_vpu(vpu_id: str, output_gpkg_path: Path, hydrofabric: Path = file_paths.conus_hydrofabric):
-
+def subset_vpu(
+    vpu_id: str, output_gpkg_path: Path, hydrofabric: Path = file_paths.conus_hydrofabric
+):
     if output_gpkg_path.exists():
         os.remove(output_gpkg_path)
 
@@ -68,7 +69,6 @@ def subset(
     output_gpkg_path: Path = Path(),
     include_outlet: bool = True,
 ):
-    print(cat_ids)
     upstream_ids = list(get_upstream_ids(cat_ids, include_outlet))
 
     if not output_gpkg_path:

map_app/static/css/main.css

@@ -109,7 +109,7 @@ h2 {
 }
 
 #selected-basins,
-#cli-command {
+#cli-command,#cli-prefix {
   background: var(--code-bg);
   padding: 16px;
   border-radius: var(--border-radius);
@@ -119,6 +119,7 @@ h2 {
   color: var(--text-color);
 }
 
+
 button {
   background-color: var(--primary-color);
   color: light-dark(white, #f1f5f9);
@@ -204,6 +205,11 @@ input[type="datetime-local"] {
   display: inline-block;
 }
 
+#command-builder{
+    display: inline-block;
+    padding:16px ;
+}
+
 .command-container {
   background: var(--surface-color);
   border: 1px solid var(--border-color);
@@ -222,7 +228,7 @@ input[type="datetime-local"] {
   border-top-right-radius: var(--border-radius);
 }
 
-.command-header span {
+.command-header>span {
   font-size: 0.875rem;
   color: var(--secondary-text);
   font-weight: 500;
@@ -254,7 +260,8 @@ input[type="datetime-local"] {
 }
 
 .command-content {
-  padding: 16px;
+    display:inline;
+  padding: 0px !important;
   background: var(--code-bg);
   font-family: 'Monaco', 'Consolas', monospace;
   font-size: 0.875rem;
@@ -263,6 +270,11 @@ input[type="datetime-local"] {
   border-bottom-left-radius: var(--border-radius);
   border-bottom-right-radius: var(--border-radius);
   color: var(--text-color);
+
+}
+
+#cli-prefix{
+    opacity: 0;
 }
 
 .copy-button.copied {
@@ -281,17 +293,17 @@ input[type="datetime-local"] {
   body {
       padding: 16px;
   }
-  
+
   main {
       width: 90vw;
   }
-  
+
   .time-input {
       flex-direction: column;
       align-items: flex-start;
   }
-  
+
   input[type="datetime-local"] {
       width: 100%;
   }
-}
+}