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

ras_commander/RasPrj.py

@@ -160,93 +160,96 @@ class RasPrj:
         Load project data from the HEC-RAS project file.
 
         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.
+        and ensures all required columns are present with appropriate paths.
         """
-        # Load unsteady first to ensure consistent handling of unsteady numbers
-        self.unsteady_df = self._get_prj_entries('Unsteady')
-        self.plan_df = self._get_prj_entries('Plan')
-        self.flow_df = self._get_prj_entries('Flow')
-        self.geom_df = self.get_geom_entries()
+        try:
+            # Load data frames
+            self.unsteady_df = self._get_prj_entries('Unsteady')
+            self.plan_df = self._get_prj_entries('Plan')
+            self.flow_df = self._get_prj_entries('Flow')
+            self.geom_df = self.get_geom_entries()
+            
+            # Ensure required columns exist
+            self._ensure_required_columns()
+            
+            # Set paths for geometry and flow files
+            self._set_file_paths()
+            
+        except Exception as e:
+            logger.error(f"Error loading project data: {e}")
+            raise
+
+    def _ensure_required_columns(self):
+        """Ensure all required columns exist in plan_df."""
+        required_columns = [
+            'plan_number', 'unsteady_number', 'geometry_number',
+            'Geom File', 'Geom Path', 'Flow File', 'Flow Path', 'full_path'
+        ]
         
-        # Initialize Geom_File column
-        self.plan_df['Geom_File'] = None
+        for col in required_columns:
+            if col not in self.plan_df.columns:
+                self.plan_df[col] = None
         
-        # Set geometry HDF paths
+        if not self.plan_df['full_path'].any():
+            self.plan_df['full_path'] = self.plan_df['plan_number'].apply(
+                lambda x: str(self.project_folder / f"{self.project_name}.p{x}")
+            )
+
+    def _set_file_paths(self):
+        """Set geometry and flow paths in plan_df."""
         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
-                    if not self.suppress_logging:
-                        logger.info(f"Plan {row['plan_number']} uses geometry file {geom_number}")
+                self._set_geom_path(idx, row)
+                self._set_flow_path(idx, row)
+                
+                if not self.suppress_logging:
+                    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}")
 
-    def _get_geom_file_from_plan(self, plan_file_path):
-        """
-        Extract the geometry number from a plan file by finding the Geom File value
-        and stripping the leading 'g'.
-        
-        Parameters:
-        -----------
-        plan_file_path : str or Path
-            Path to the plan file.
-        
-        Returns:
-        --------
-        tuple: (str, str)
-            A tuple containing (geometry_number, full_hdf_path) or (None, None) if not found.
-            geometry_number is the number after 'g' in the Geom File value
-            full_hdf_path is the path to the geometry HDF file
-        """
-        content, encoding = read_file_with_fallback_encoding(plan_file_path)
-        
-        if content is None:
-            return None, None
-        
-        try:
-            match = re.search(r'Geom File=g(\d+)', content)
-            if match:
-                geom_number = match.group(1)  # This gets just the number after 'g'
-                geom_file = f"g{geom_number}"
-                geom_hdf_path = self.project_folder / f"{self.project_name}.{geom_file}.hdf"
-                if geom_hdf_path.exists():
-                    return geom_number, str(geom_hdf_path)
-        except Exception as e:
-            logger.error(f"Error extracting geometry number from {plan_file_path}: {e}")
-        
-        return None, None
+    def _set_geom_path(self, idx: int, row: pd.Series):
+        """Set geometry path for a plan entry."""
+        if pd.notna(row['Geom File']):
+            geom_path = self.project_folder / f"{self.project_name}.g{row['Geom File']}"
+            self.plan_df.at[idx, 'Geom Path'] = str(geom_path)
 
-    def _get_flow_file_from_plan(self, plan_file_path):
+    def _set_flow_path(self, idx: int, row: pd.Series):
+        """Set flow path for a plan entry."""
+        if pd.notna(row['Flow File']):
+            prefix = 'u' if pd.notna(row['unsteady_number']) else 'f'
+            flow_path = self.project_folder / f"{self.project_name}.{prefix}{row['Flow File']}"
+            self.plan_df.at[idx, 'Flow Path'] = str(flow_path)
+
+    def _get_geom_file_for_plan(self, plan_number):
         """
-        Extract the Flow File value from a plan file.
+        Get the geometry file path for a given plan number.
         
-        Parameters:
-        -----------
-        plan_file_path : str or Path
-            Path to the plan file.
+        Args:
+            plan_number (str): The plan number to find the geometry file for.
         
         Returns:
-        --------
-        str or None
-            The Flow File value or None if not found.
+            str: The full path to the geometry HDF file, or None if not found.
         """
+        plan_file_path = self.project_folder / f"{self.project_name}.p{plan_number}"
         content, encoding = read_file_with_fallback_encoding(plan_file_path)
         
         if content is None:
             return None
         
         try:
-            match = re.search(r'Flow File=([^\s]+)', content)
-            if match:
-                return match.group(1)
+            for line in content.splitlines():
+                if line.startswith("Geom File="):
+                    geom_file = line.strip().split('=')[1]
+                    geom_hdf_path = self.project_folder / f"{self.project_name}.{geom_file}.hdf"
+                    if geom_hdf_path.exists():
+                        return str(geom_hdf_path)
+                    else:
+                        return None
         except Exception as e:
-            logger.error(f"Error extracting Flow File from {plan_file_path}: {e}")
-        
+            logger.error(f"Error reading plan file for geometry: {e}")
         return None
 
+
     @staticmethod
     @log_call
     def get_plan_value(
@@ -431,80 +434,106 @@ class RasPrj:
         
         Returns:
             pd.DataFrame: A DataFrame containing the extracted entries.
+        
+        Raises:
+            Exception: If there's an error reading or processing the project file.
         """
         entries = []
         pattern = re.compile(rf"{entry_type} File=(\w+)")
 
         try:
-            with open(self.prj_file, 'r') as file:
+            with open(self.prj_file, 'r', encoding='utf-8') as file:
                 for line in file:
                     match = pattern.match(line.strip())
                     if match:
                         file_name = match.group(1)
                         full_path = str(self.project_folder / f"{self.project_name}.{file_name}")
-                        entry_number = file_name[1:]  # Extract number portion without prefix
+                        entry_number = file_name[1:]
                         
                         entry = {
                             f'{entry_type.lower()}_number': entry_number,
                             'full_path': full_path
                         }
                         
+                        # Handle Unsteady entries
                         if entry_type == 'Unsteady':
-                            entry['unsteady_number'] = entry_number
-                            unsteady_info = self._parse_unsteady_file(Path(full_path))
-                            entry.update(unsteady_info)
+                            entry.update(self._process_unsteady_entry(entry_number, full_path))
                         else:
-                            entry.update({
-                                'unsteady_number': None,
-                                'geometry_number': None,
-                                'Short Identifier': None,
-                                'Simulation Date': None
-                            })
+                            entry.update(self._process_default_entry())
                         
+                        # Handle Plan entries
                         if entry_type == 'Plan':
-                            plan_info = self._parse_plan_file(Path(full_path))
-                            if plan_info:
-                                # Handle Flow File (unsteady) number
-                                flow_file = plan_info.get('Flow File')
-                                if flow_file and flow_file.startswith('u'):
-                                    entry['unsteady_number'] = flow_file[1:]
-                                else:
-                                    entry['unsteady_number'] = flow_file
-                                    
-                                # 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:]
-                                else:
-                                    entry['geometry_number'] = geom_file
-                                    
-                                entry['Short Identifier'] = plan_info.get('Short Identifier')
-                                entry['Simulation Date'] = plan_info.get('Simulation Date')
-                                
-                                # Update remaining fields
-                                for key, value in plan_info.items():
-                                    if key not in ['unsteady_number', 'geometry_number', 'Short Identifier', 
-                                                 'Simulation Date', 'Flow File', 'Geom File']:
-                                        entry[key] = value
+                            entry.update(self._process_plan_entry(entry_number, full_path))
                         
-                            # Add HDF results path
-                            hdf_results_path = self.project_folder / f"{self.project_name}.p{entry_number}.hdf"
-                            entry['HDF_Results_Path'] = str(hdf_results_path) if hdf_results_path.exists() else None
-
                         entries.append(entry)
-        
-            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]
             
-            return df
+            df = pd.DataFrame(entries)
+            return self._format_dataframe(df, entry_type)
+        
         except Exception as e:
+            logger.error(f"Error in _get_prj_entries for {entry_type}: {e}")
             raise
 
+    def _process_unsteady_entry(self, entry_number: str, full_path: str) -> dict:
+        """Process unsteady entry data."""
+        entry = {'unsteady_number': entry_number}
+        unsteady_info = self._parse_unsteady_file(Path(full_path))
+        entry.update(unsteady_info)
+        return entry
+
+    def _process_default_entry(self) -> dict:
+        """Process default entry data."""
+        return {
+            'unsteady_number': None,
+            'geometry_number': None
+        }
+
+    def _process_plan_entry(self, entry_number: str, full_path: str) -> dict:
+        """Process plan entry data."""
+        entry = {}
+        plan_info = self._parse_plan_file(Path(full_path))
+        
+        if plan_info:
+            entry.update(self._process_flow_file(plan_info))
+            entry.update(self._process_geom_file(plan_info))
+            
+            # Add remaining plan info
+            for key, value in plan_info.items():
+                if key not in ['Flow File', 'Geom File']:
+                    entry[key] = value
+            
+            # Add HDF results path
+            hdf_results_path = self.project_folder / f"{self.project_name}.p{entry_number}.hdf"
+            entry['HDF_Results_Path'] = str(hdf_results_path) if hdf_results_path.exists() else None
+        
+        return entry
+
+    def _process_flow_file(self, plan_info: dict) -> dict:
+        """Process flow file information from plan info."""
+        flow_file = plan_info.get('Flow File')
+        if flow_file and flow_file.startswith('u'):
+            return {
+                'unsteady_number': flow_file[1:],
+                'Flow File': flow_file[1:]
+            }
+        return {
+            'unsteady_number': None,
+            'Flow File': flow_file[1:] if flow_file and flow_file.startswith('f') else None
+        }
+
+    def _process_geom_file(self, plan_info: dict) -> dict:
+        """Process geometry file information from plan info."""
+        geom_file = plan_info.get('Geom File')
+        if geom_file and geom_file.startswith('g'):
+            return {
+                'geometry_number': geom_file[1:],
+                'Geom File': geom_file[1:]
+            }
+        return {
+            'geometry_number': None,
+            'Geom File': None
+        }
+
     def _parse_unsteady_file(self, unsteady_file_path):
         """
         Parse an unsteady flow file and extract critical information.
@@ -895,27 +924,135 @@ class RasPrj:
         return bc_info, unparsed_lines
 
     @log_call
-    def get_unsteady_numbers_from_plans(self):
+    def _format_dataframe(self, df, entry_type):
         """
-        Get all plans that use unsteady flow files.
+        Format the DataFrame according to the desired column structure.
+        
+        Args:
+            df (pd.DataFrame): The DataFrame to format.
+            entry_type (str): The type of entry (e.g., 'Plan', 'Flow', 'Unsteady', 'Geom').
         
         Returns:
-        --------
-        pd.DataFrame
-            A DataFrame containing only plan entries that use unsteady flow files.
+            pd.DataFrame: The formatted DataFrame.
+        """
+        if df.empty:
+            return df
         
-        Raises:
-        -------
-        RuntimeError: If the project has not been initialized.
+        if entry_type == 'Plan':
+            # Define column groups
+            first_cols = ['plan_number', 'unsteady_number', 'geometry_number']
+            plan_key_cols = [
+                'Plan Title', 'Program Version', 'Short Identifier', 'Simulation Date',
+                'Computation Interval', 'Mapping Interval', 'Run HTab', 'Run UNet', 
+                'Run Sediment', 'Run PostProcess', 'Run WQNet', 'UNET Use Existing IB Tables', 
+                'HDF_Results_Path', 'UNET 1D Methodology'
+            ]
+            file_path_cols = ['Geom File', 'Geom Path', 'Flow File', 'Flow Path']
+            
+            # Build column list
+            all_cols = first_cols.copy()
+            all_cols.extend([col for col in plan_key_cols if col in df.columns])
+            all_cols.extend([col for col in df.columns if col not in all_cols + file_path_cols + ['full_path']])
+            all_cols.extend(file_path_cols)
+            
+            # Rename and fill missing columns
+            df = df.rename(columns={f'{entry_type.lower()}_number': 'plan_number'})
+            for col in all_cols:
+                if col not in df.columns:
+                    df[col] = None
+            
+            # Add full_path if present
+            if 'full_path' in df.columns:
+                all_cols.append('full_path')
+            
+            return df[[col for col in all_cols if col in df.columns]]
+        
+        return df
+
+    @log_call
+    def _get_prj_entries(self, entry_type):
         """
-        self.check_initialized()
+        Extract entries of a specific type from the HEC-RAS project file.
+        """
+        entries = []
+        pattern = re.compile(rf"{entry_type} File=(\w+)")
+
+        try:
+            with open(self.prj_file, 'r') as file:
+                for line in file:
+                    match = pattern.match(line.strip())
+                    if match:
+                        file_name = match.group(1)
+                        full_path = str(self.project_folder / f"{self.project_name}.{file_name}")
+                        entry = self._create_entry(entry_type, file_name, full_path)
+                        entries.append(entry)
         
-        # Filter plan_df to only include plans with unsteady_number not None
-        unsteady_plans = self.plan_df[self.plan_df['unsteady_number'].notna()].copy()
+            return self._format_dataframe(pd.DataFrame(entries), entry_type)
         
-        logger.info(f"Found {len(unsteady_plans)} plans using unsteady flow files")
+        except Exception as e:
+            logger.error(f"Error in _get_prj_entries for {entry_type}: {e}")
+            raise
+
+    def _create_entry(self, entry_type, file_name, full_path):
+        """Helper method to create entry dictionary."""
+        entry_number = file_name[1:]
+        entry = {
+            f'{entry_type.lower()}_number': entry_number,
+            'full_path': full_path,
+            'unsteady_number': None,
+            'geometry_number': None
+        }
+        
+        if entry_type == 'Unsteady':
+            entry['unsteady_number'] = entry_number
+            entry.update(self._parse_unsteady_file(Path(full_path)))
+        elif entry_type == 'Plan':
+            self._update_plan_entry(entry, entry_number, full_path)
         
-        return unsteady_plans
+        return entry
+
+    def _update_plan_entry(self, entry, entry_number, full_path):
+        """Helper method to update plan entry with additional information."""
+        plan_info = self._parse_plan_file(Path(full_path))
+        if plan_info:
+            # Handle Flow File
+            flow_file = plan_info.get('Flow File')
+            if flow_file:
+                if flow_file.startswith('u'):
+                    entry.update({'unsteady_number': flow_file[1:], 'Flow File': flow_file[1:]})
+                else:
+                    entry['Flow File'] = flow_file[1:] if flow_file.startswith('f') else None
+            
+            # Handle Geom File
+            geom_file = plan_info.get('Geom File')
+            if geom_file and geom_file.startswith('g'):
+                entry.update({'geometry_number': geom_file[1:], 'Geom File': geom_file[1:]})
+            
+            # Add remaining plan info
+            entry.update({k: v for k, v in plan_info.items() if k not in ['Flow File', 'Geom File']})
+            
+            # Add HDF results path
+            hdf_path = self.project_folder / f"{self.project_name}.p{entry_number}.hdf"
+            entry['HDF_Results_Path'] = str(hdf_path) if hdf_path.exists() else None
+
+    def _set_plan_paths(self):
+        """Helper method to set paths in plan_df."""
+        if not self.plan_df['full_path'].any():
+            self.plan_df['full_path'] = self.plan_df['plan_number'].apply(
+                lambda x: str(self.project_folder / f"{self.project_name}.p{x}")
+            )
+        
+        for idx, row in self.plan_df.iterrows():
+            if pd.notna(row['Geom File']) and pd.isna(row.get('Geom Path')):
+                self.plan_df.at[idx, 'Geom Path'] = str(self.project_folder / f"{self.project_name}.g{row['Geom File']}")
+            
+            if pd.notna(row['Flow File']) and pd.isna(row.get('Flow Path')):
+                prefix = 'u' if pd.notna(row['unsteady_number']) else 'f'
+                self.plan_df.at[idx, 'Flow Path'] = str(self.project_folder / f"{self.project_name}.{prefix}{row['Flow File']}")
+            
+            if not self.suppress_logging:
+                logger.info(f"Plan {row['plan_number']} paths set up")
+
 
 # Create a global instance named 'ras'
 # Defining the global instance allows the init_ras_project function to initialize the project.
@@ -987,7 +1124,7 @@ def get_ras_exe(ras_version=None):
     Args:
         ras_version (str, optional): Either a version number or a full path to the HEC-RAS executable.
                                      If None, the function will first check the global 'ras' object for a path.
-                                     If the global 'ras' object is not initialized or doesn't have a path, a default path will be used.
+                                     or a default path.
     
     Returns:
         str: The full path to the HEC-RAS executable.

ras_commander/RasUtils.py

@@ -216,30 +216,49 @@ class RasUtils:
         Returns:
         Path: Full path to the plan file
 
+        Raises:
+        ValueError: If plan number is not between 1 and 99
+        TypeError: If input type is invalid
+        FileNotFoundError: If the plan file does not exist
+
         Example:
         >>> plan_path = RasUtils.get_plan_path(1)
         >>> print(f"Plan file path: {plan_path}")
         >>> plan_path = RasUtils.get_plan_path("path/to/plan.p01")
         >>> print(f"Plan file path: {plan_path}")
         """
-        
+        # Validate RAS object
         ras_obj = ras_object or ras
         ras_obj.check_initialized()
         
+        # Handle direct file path input
         plan_path = Path(current_plan_number_or_path)
         if plan_path.is_file():
             logger.info(f"Using provided plan file path: {plan_path}")
             return plan_path
         
+        # Handle plan number input
         try:
-            current_plan_number = f"{int(current_plan_number_or_path):02d}"  # Ensure two-digit format
+            plan_num = int(current_plan_number_or_path)
+            if not 1 <= plan_num <= 99:
+                raise ValueError(f"Plan number must be between 1 and 99, got: {plan_num}")
+            current_plan_number = f"{plan_num:02d}"  # Ensure two-digit format
             logger.debug(f"Converted plan number to two-digit format: {current_plan_number}")
-        except ValueError:
+        except (ValueError, TypeError) as e:
+            if isinstance(e, TypeError):
+                logger.error(f"Invalid input type: {type(current_plan_number_or_path)}. Expected string, number, or Path.")
+                raise TypeError(f"Invalid input type: {type(current_plan_number_or_path)}. Expected string, number, or Path.")
             logger.error(f"Invalid plan number: {current_plan_number_or_path}. Expected a number from 1 to 99.")
             raise ValueError(f"Invalid plan number: {current_plan_number_or_path}. Expected a number from 1 to 99.")
         
+        # Construct and validate plan path
         plan_name = f"{ras_obj.project_name}.p{current_plan_number}"
         full_plan_path = ras_obj.project_folder / plan_name
+        
+        if not full_plan_path.exists():
+            logger.error(f"Plan file does not exist: {full_plan_path}")
+            raise FileNotFoundError(f"Plan file does not exist: {full_plan_path}")
+        
         logger.info(f"Constructed plan file path: {full_plan_path}")
         return full_plan_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.66.0"
 
 # Set up logging
 setup_logging()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ras-commander
-Version: 0.64.0
+Version: 0.66.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.66.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=0THxeB9ldeDuS4of2ruYG7Abbc5jz2729y5qOHntMuI,61664
+ras_commander/RasPrj.py,sha256=gQoGG1Mqsoj5W1oVlulqhA0kQ5eD69vI96uihnY-kLE,47744
 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/RasUtils.py,sha256=0fm4IIs0LH1dgDj3pGd66mR82DhWLEkRKUvIo2M_5X0,35886
+ras_commander/__init__.py,sha256=KICL5peRDDjE2BXEFVDMmtDZ4TKHtNhHh5eQgTSdqqs,2001
+ras_commander-0.66.0.dist-info/LICENSE,sha256=_pbd6qHnlsz1iQ-ozDW_49r86BZT6CRwO2iBtw0iN6M,457
+ras_commander-0.66.0.dist-info/METADATA,sha256=-jPNaFlPs0iCcscfGjO31DwF3-LT632rbiunJQmYzoM,26233
+ras_commander-0.66.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+ras_commander-0.66.0.dist-info/top_level.txt,sha256=i76S7eKLFC8doKcXDl3aiOr9RwT06G8adI6YuKbQDaA,14
+ras_commander-0.66.0.dist-info/RECORD,,