ras-commander 0.64.0__py3-none-any.whl → 0.65.0__py3-none-any.whl

ras_commander/RasPlan.py

@@ -105,11 +105,10 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
 
-        # Ensure plan_number and new_geom are strings
         plan_number = str(plan_number).zfill(2)
         new_geom = str(new_geom).zfill(2)
 
-        # Before doing anything, make sure the plan, geom, flow, and unsteady dataframes are current
+        # Update all dataframes
         ras_obj.plan_df = ras_obj.get_plan_entries()
         ras_obj.geom_df = ras_obj.get_geom_entries()
         ras_obj.flow_df = ras_obj.get_flow_entries()
@@ -119,18 +118,15 @@ class RasPlan:
             logger.error(f"Geometry {new_geom} not found in project.")
             raise ValueError(f"Geometry {new_geom} not found in project.")
 
-        # Update the geometry for the specified plan
-        ras_obj.plan_df.loc[ras_obj.plan_df['plan_number'] == plan_number, 'geom_number'] = new_geom
+        # Update all geometry-related columns
+        mask = ras_obj.plan_df['plan_number'] == plan_number
+        ras_obj.plan_df.loc[mask, 'geometry_number'] = new_geom
+        ras_obj.plan_df.loc[mask, 'Geom File'] = new_geom
+        geom_path = ras_obj.project_folder / f"{ras_obj.project_name}.g{new_geom}"
+        ras_obj.plan_df.loc[mask, 'Geom Path'] = str(geom_path)
 
-        logger.info(f"Geometry for plan {plan_number} set to {new_geom}")
-        logger.debug("Updated plan DataFrame:")
-        logger.debug(ras_obj.plan_df)
-
-        # Update the project file
-        prj_file_path = ras_obj.prj_file
-        RasUtils.update_file(prj_file_path, RasPlan._update_geom_in_file, plan_number, new_geom)
-
-        # Re-initialize the ras object to reflect changes
+        # Update project file and reinitialize
+        RasUtils.update_file(ras_obj.prj_file, RasPlan._update_geom_in_file, plan_number, new_geom)
         ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
 
         return ras_obj.plan_df
@@ -177,21 +173,26 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
                         
-        # Update the flow dataframe in the ras instance to ensure it is current
         ras_obj.flow_df = ras_obj.get_flow_entries()
         
         if new_steady_flow_number not in ras_obj.flow_df['flow_number'].values:
             raise ValueError(f"Steady flow number {new_steady_flow_number} not found in project file.")
         
-        # Resolve the full path of the plan file
         plan_file_path = RasPlan.get_plan_path(plan_number, ras_obj)
         if not plan_file_path:
             raise FileNotFoundError(f"Plan file not found: {plan_number}")
         
         RasUtils.update_file(plan_file_path, RasPlan._update_steady_in_file, new_steady_flow_number)
 
-        # Update the ras object's dataframes
+        # Update dataframes and additional columns
         ras_obj.plan_df = ras_obj.get_plan_entries()
+        mask = ras_obj.plan_df['plan_number'] == plan_number
+        flow_path = ras_obj.project_folder / f"{ras_obj.project_name}.f{new_steady_flow_number}"
+        ras_obj.plan_df.loc[mask, 'Flow File'] = new_steady_flow_number
+        ras_obj.plan_df.loc[mask, 'Flow Path'] = str(flow_path)
+        ras_obj.plan_df.loc[mask, 'unsteady_number'] = None
+
+        # Update remaining dataframes
         ras_obj.geom_df = ras_obj.get_geom_entries()
         ras_obj.flow_df = ras_obj.get_flow_entries()
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
@@ -227,37 +228,37 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
-        # Update the unsteady dataframe in the ras instance to ensure it is current
         ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
         
         if new_unsteady_flow_number not in ras_obj.unsteady_df['unsteady_number'].values:
             raise ValueError(f"Unsteady number {new_unsteady_flow_number} not found in project file.")
         
-        # Get the full path of the plan file
         plan_file_path = RasPlan.get_plan_path(plan_number, ras_obj)
         if not plan_file_path:
             raise FileNotFoundError(f"Plan file not found: {plan_number}")
         
-        def update_unsteady_in_file(lines):
-            updated_lines = []
-            for line in lines:
-                if line.startswith("Flow File="):
-                    updated_lines.append(f"Flow File=u{new_unsteady_flow_number}\n")
-                else:
-                    updated_lines.append(line)
-            return updated_lines
-        
         try:
-            RasUtils.update_file(plan_file_path, update_unsteady_in_file)
+            RasUtils.update_file(plan_file_path, lambda lines: [
+                f"Flow File=u{new_unsteady_flow_number}\n" if line.startswith("Flow File=") else line 
+                for line in lines
+            ])
+            
+            # Update dataframes and additional columns
+            ras_obj.plan_df = ras_obj.get_plan_entries()
+            mask = ras_obj.plan_df['plan_number'] == plan_number
+            flow_path = ras_obj.project_folder / f"{ras_obj.project_name}.u{new_unsteady_flow_number}"
+            ras_obj.plan_df.loc[mask, 'Flow File'] = new_unsteady_flow_number
+            ras_obj.plan_df.loc[mask, 'Flow Path'] = str(flow_path)
+            ras_obj.plan_df.loc[mask, 'unsteady_number'] = new_unsteady_flow_number
+            
+            # Update remaining dataframes
+            ras_obj.geom_df = ras_obj.get_geom_entries()
+            ras_obj.flow_df = ras_obj.get_flow_entries()
+            ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
+            
         except Exception as e:
             raise Exception(f"Failed to update unsteady flow file: {e}")
 
-        # Update the ras object's dataframes
-        ras_obj.plan_df = ras_obj.get_plan_entries()
-        ras_obj.geom_df = ras_obj.get_geom_entries()
-        ras_obj.flow_df = ras_obj.get_flow_entries()
-        ras_obj.unsteady_df = ras_obj.get_unsteady_entries()
-
     @staticmethod
     @log_call
     def set_num_cores(plan_number, num_cores, ras_object=None):
@@ -610,36 +611,31 @@ class RasPlan:
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
 
-        # Update plan entries without reinitializing the entire project
         ras_obj.plan_df = ras_obj.get_prj_entries('Plan')
-
         new_plan_num = RasPlan.get_next_number(ras_obj.plan_df['plan_number'])
+        
         template_plan_path = ras_obj.project_folder / f"{ras_obj.project_name}.p{template_plan}"
         new_plan_path = ras_obj.project_folder / f"{ras_obj.project_name}.p{new_plan_num}"
 
-        def update_shortid(lines):
-            shortid_pattern = re.compile(r'^Short Identifier=(.*)$', re.IGNORECASE)
-            for i, line in enumerate(lines):
-                match = shortid_pattern.match(line.strip())
-                if match:
-                    current_shortid = match.group(1)
-                    if new_plan_shortid is None:
-                        new_shortid = (current_shortid + "_copy")[:24]
-                    else:
-                        new_shortid = new_plan_shortid[:24]
-                    lines[i] = f"Short Identifier={new_shortid}\n"
-                    break
-            return lines
-
-        # Use RasUtils to clone the file and update the short identifier
-        RasUtils.clone_file(template_plan_path, new_plan_path, update_shortid)
-
-        # Use RasUtils to update the project file
+        # Clone file and update project file
+        RasUtils.clone_file(template_plan_path, new_plan_path, 
+                           lambda lines: [
+                               f"Short Identifier={new_plan_shortid or (match.group(1) + '_copy')[:24]}\n"
+                               if (match := re.match(r'^Short Identifier=(.*)$', line.strip(), re.IGNORECASE))
+                               else line
+                               for line in lines
+                           ])
+        
         RasUtils.update_project_file(ras_obj.prj_file, 'Plan', new_plan_num, ras_object=ras_obj)
-
-        # Re-initialize the ras global object
         ras_obj.initialize(ras_obj.project_folder, ras_obj.ras_exe_path)
+        
+        # Copy additional columns from template to new plan
+        template_row = ras_obj.plan_df[ras_obj.plan_df['plan_number'] == template_plan].iloc[0]
+        for col in ['Geom File', 'Geom Path', 'Flow File', 'Flow Path']:
+            if col in template_row.index:
+                ras_obj.plan_df.loc[ras_obj.plan_df['plan_number'] == new_plan_num, col] = template_row[col]
 
+        # Update all dataframes
         ras_obj.plan_df = ras_obj.get_plan_entries()
         ras_obj.geom_df = ras_obj.get_geom_entries()
         ras_obj.flow_df = ras_obj.get_flow_entries()
@@ -890,7 +886,8 @@ class RasPlan:
             'Run HTab', 'Run Post Process', 'Run Sediment', 'Run UNET', 'Run WQNET',
             'Short Identifier', 'Simulation Date', 'UNET D1 Cores', 'UNET D2 Cores', 'PS Cores',
             'UNET Use Existing IB Tables', 'UNET 1D Methodology', 'UNET D2 Solver Type', 
-            'UNET D2 Name', 'Run RASMapper', 'Run HTab', 'Run UNET'
+            'UNET D2 Name', 'Run RASMapper', 'Run HTab', 'Run UNet', 'Run PostProcess',
+            'Run WQNet', 'UNET P2 Cores', 'Run Post Process', 'Run WQNET'
         }
 
         if key not in supported_plan_keys:

ras_commander/RasPrj.py

@@ -162,6 +162,7 @@ class RasPrj:
         This method initializes DataFrames for plan, flow, unsteady, and geometry entries
         by calling the _get_prj_entries method for each entry type.
         Also extracts unsteady_number and geometry_number from plan files and adds them to plan_df.
+        Now includes Geom Path, Flow Path, and other required columns.
         """
         # Load unsteady first to ensure consistent handling of unsteady numbers
         self.unsteady_df = self._get_prj_entries('Unsteady')
@@ -169,18 +170,25 @@ class RasPrj:
         self.flow_df = self._get_prj_entries('Flow')
         self.geom_df = self.get_geom_entries()
         
-        # Initialize Geom_File column
-        self.plan_df['Geom_File'] = None
-        
-        # Set geometry HDF paths
+        # Set geometry and flow paths
         for idx, row in self.plan_df.iterrows():
             try:
-                plan_file_path = row['full_path']
-                geom_number, geom_hdf_path = self._get_geom_file_from_plan(plan_file_path)
-                if geom_number:
-                    self.plan_df.at[idx, 'Geom_File'] = geom_hdf_path
+                # Add Geom Path
+                if row['Geom File'] is not None:
+                    geom_hdf_path = self.project_folder / f"{self.project_name}.g{row['Geom File']}"
+                    self.plan_df.at[idx, 'Geom Path'] = str(geom_hdf_path)
+                
+                # Add Flow Path
+                if row['Flow File'] is not None:
+                    # Determine if this is a steady or unsteady flow file
+                    if row['unsteady_number'] is not None:
+                        flow_path = self.project_folder / f"{self.project_name}.u{row['Flow File']}"
+                    else:
+                        flow_path = self.project_folder / f"{self.project_name}.f{row['Flow File']}"
+                    self.plan_df.at[idx, 'Flow Path'] = str(flow_path)
+                
                     if not self.suppress_logging:
-                        logger.info(f"Plan {row['plan_number']} uses geometry file {geom_number}")
+                        logger.info(f"Plan {row['plan_number']} paths set up")
             except Exception as e:
                 logger.error(f"Error processing plan file {row['plan_number']}: {e}")
 
@@ -456,9 +464,7 @@ class RasPrj:
                         else:
                             entry.update({
                                 'unsteady_number': None,
-                                'geometry_number': None,
-                                'Short Identifier': None,
-                                'Simulation Date': None
+                                'geometry_number': None
                             })
                         
                         if entry_type == 'Plan':
@@ -468,23 +474,23 @@ class RasPrj:
                                 flow_file = plan_info.get('Flow File')
                                 if flow_file and flow_file.startswith('u'):
                                     entry['unsteady_number'] = flow_file[1:]
+                                    entry['Flow File'] = flow_file[1:]
                                 else:
-                                    entry['unsteady_number'] = flow_file
+                                    entry['unsteady_number'] = None
+                                    entry['Flow File'] = flow_file[1:] if flow_file and flow_file.startswith('f') else None
                                     
                                 # Handle Geom File number
                                 geom_file = plan_info.get('Geom File')
                                 if geom_file and geom_file.startswith('g'):
                                     entry['geometry_number'] = geom_file[1:]
+                                    entry['Geom File'] = geom_file[1:]
                                 else:
-                                    entry['geometry_number'] = geom_file
-                                    
-                                entry['Short Identifier'] = plan_info.get('Short Identifier')
-                                entry['Simulation Date'] = plan_info.get('Simulation Date')
+                                    entry['geometry_number'] = None
+                                    entry['Geom File'] = None
                                 
-                                # Update remaining fields
+                                # Add all plan key information with exact same names
                                 for key, value in plan_info.items():
-                                    if key not in ['unsteady_number', 'geometry_number', 'Short Identifier', 
-                                                 'Simulation Date', 'Flow File', 'Geom File']:
+                                    if key not in ['Flow File', 'Geom File']:
                                         entry[key] = value
                         
                             # Add HDF results path
@@ -496,13 +502,47 @@ class RasPrj:
             df = pd.DataFrame(entries)
             
             if not df.empty and entry_type == 'Plan':
-                first_cols = [f'{entry_type.lower()}_number', 'unsteady_number', 'geometry_number', 
-                            'Short Identifier', 'Simulation Date']
-                other_cols = [col for col in df.columns if col not in first_cols]
-                df = df[first_cols + other_cols]
+                # Set required column order
+                first_cols = ['plan_number', 'unsteady_number', 'geometry_number']
+                
+                # Standard plan key columns in the exact order specified
+                plan_key_cols = [
+                    'Plan Title', 'Program Version', 'Short Identifier', 'Simulation Date',
+                    'Std Step Tol', 'Computation Interval', 'Output Interval', 'Instantaneous Interval',
+                    'Mapping Interval', 'Run HTab', 'Run UNet', 'Run Sediment', 'Run PostProcess',
+                    'Run WQNet', 'Run RASMapper', 'UNET Use Existing IB Tables', 'HDF_Results_Path',
+                    'UNET 1D Methodology', 'Write IC File', 'Write IC File at Fixed DateTime',
+                    'IC Time', 'Write IC File Reoccurance', 'Write IC File at Sim End'
+                ]
+                
+                # Additional convenience columns
+                file_path_cols = ['Geom File', 'Geom Path', 'Flow File', 'Flow Path']
+                
+                # Build the final column list
+                all_cols = first_cols.copy()
+                for col in plan_key_cols:
+                    if col in df.columns:
+                        all_cols.append(col)
+                
+                # Add any remaining columns not explicitly specified
+                other_cols = [col for col in df.columns if col not in all_cols + file_path_cols + ['full_path']]
+                all_cols.extend(other_cols)
+                all_cols.extend(file_path_cols)
+                
+                # Rename plan_number column
+                df = df.rename(columns={f'{entry_type.lower()}_number': 'plan_number'})
+                
+                # Fill in missing columns with None
+                for col in all_cols:
+                    if col not in df.columns:
+                        df[col] = None
+                
+                # Return DataFrame with specified column order
+                return df[all_cols]
             
             return df
         except Exception as e:
+            logger.error(f"Error in _get_prj_entries for {entry_type}: {e}")
             raise
 
     def _parse_unsteady_file(self, unsteady_file_path):

ras_commander/__init__.py

@@ -10,7 +10,7 @@ try:
     __version__ = version("ras-commander")
 except PackageNotFoundError:
     # package is not installed
-    __version__ = "0.64.0"
+    __version__ = "0.65.0"
 
 # Set up logging
 setup_logging()

{ras_commander-0.64.0.dist-info → ras_commander-0.65.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ras-commander
-Version: 0.64.0
+Version: 0.65.0
 Summary: A Python library for automating HEC-RAS 6.x operations
 Home-page: https://github.com/gpt-cmdr/ras-commander
 Author: William M. Katzenmeyer, P.E., C.F.M.

{ras_commander-0.64.0.dist-info → ras_commander-0.65.0.dist-info}/RECORD

@@ -21,14 +21,14 @@ ras_commander/RasExamples.py,sha256=6IZ96LcAsk5LYFehdD0zDW5wyZWxQa6OQu2N9upxWXA,
 ras_commander/RasGeo.py,sha256=M0sVNKlWmmbve8iMXLWq25WgbxqLWBo7_1oDg_rALzU,5607
 ras_commander/RasGpt.py,sha256=N_7p2nucWrBBXdB2k2ZKvOeOdXNmFD9dIY3W7_5i5nw,1206
 ras_commander/RasMapper.py,sha256=LO_blvQnd4pwkEU8A30-RoE-CYIoU3s_fNLHBoM8ljw,613
-ras_commander/RasPlan.py,sha256=TYxFh3d6ZDqeytFcwEmtlo8TQ79wLmalo7HohBUYf40,62118
-ras_commander/RasPrj.py,sha256=KVDz4SKq-axe4AZv27H1ACrPov-ERHM9esl51p6Crfc,42560
+ras_commander/RasPlan.py,sha256=9RbOzQyz0_BCRa-gds_ca3_DImNMeX6n5NslkjpfT1w,62477
+ras_commander/RasPrj.py,sha256=b0d0A5WKkUXRtQobUcDPBTTGymtM_EWZwFbpOrNjqfY,44731
 ras_commander/RasToGo.py,sha256=TKujfaV1xQhFaOddF4g2ogGy6ky-CLlfelSMPD2J3Nk,1223
 ras_commander/RasUnsteady.py,sha256=KfCXAag-_bPwwS3JbPZH-s4hbaoHACO0mlRnGrzbFgA,32092
 ras_commander/RasUtils.py,sha256=P2-aBL61kdRINsjnBpstZVD6VVc7hI_D3RUXqr6ldmc,34863
-ras_commander/__init__.py,sha256=KGJQL7tKKaKdvY8Gtfm1QUsCX3vVxXZXF5EVStGVyk8,2001
-ras_commander-0.64.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
-ras_commander-0.64.0.dist-info/METADATA,sha256=u9uEBRrgkNsXiKrPRZDXAmhtUdCn1nVEQzIHRDDUe8c,26233
-ras_commander-0.64.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-ras_commander-0.64.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
-ras_commander-0.64.0.dist-info/RECORD,,
+ras_commander/__init__.py,sha256=Aojks8MKjFZceg9TEaTqrr6RsgLeJAh6iZrRZVoOdg0,2001
+ras_commander-0.65.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.65.0.dist-info/METADATA,sha256=7Ddh7KnY46exroA1XG0YC77l3YKdQJqiNZuyZIUtOPE,26233
+ras_commander-0.65.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+ras_commander-0.65.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.65.0.dist-info/RECORD,,