Update main_app.py

main_app.py

@@ -785,6 +785,191 @@ def _(create_yaml_tempfile, deployment_client, package_meta):
 
     return pe_metadata, yaml_file_path
 
+@app.cell(hide_code=True)
+def _():
+    ### Helper function for checking if a python library is in the standard software spec.
+    def analyze_software_spec(sw_spec_response, required_libraries, return_full_sw_package_list=False):
+        """
+        Analyzes a software specification against a list of required libraries.
+
+        Args:
+            sw_spec_response (dict): The software specification response from the API
+            required_libraries (list): List of required libraries in format ["package_name", "package_name==version", etc.]
+            return_full_sw_package_list (bool): Whether to return the complete package list from sw_spec
+
+        Returns:
+            dict: A dictionary with analysis results containing:
+                - not_present: Dict of libraries not found in the software spec
+                - version_mismatch: Dict of libraries with version mismatches, with [sw_version, required_version] as values
+                - present: Dict of libraries that are present with matching versions
+                - sw_packages: (Optional) Complete dict of all packages in the software spec
+        """
+        result = {
+            "present": {},
+            "not_present": {},
+            "version_mismatch": {}
+        }
+
+        # Extract all packages from the software specification
+        sw_packages = {}
+
+        try:
+            # Extract packages from included_packages in the software specification
+            included_packages = sw_spec_response["entity"]["software_specification"]["software_configuration"]["included_packages"]
+
+            # Create a dictionary of all packages in the software specification
+            for package in included_packages:
+                package_name = package["name"]
+                package_version = package["version"]
+                sw_packages[package_name] = package_version
+        except KeyError as e:
+            raise ValueError(f"Invalid software specification format: {e}")
+
+        # Parse required libraries
+        for lib in required_libraries:
+            if "==" in lib:
+                lib_name, lib_version = lib.split("==", 1)
+                lib_name = lib_name.strip()
+                lib_version = lib_version.strip()
+            else:
+                lib_name = lib.strip()
+                lib_version = None
+
+            # Check if library is present in software specification
+            if lib_name not in sw_packages:
+                result["not_present"][lib_name] = None
+            elif lib_version is not None and lib_version != sw_packages[lib_name]:
+                # Check version mismatch
+                result["version_mismatch"][lib_name] = [sw_packages[lib_name], lib_version]
+            else:
+                # Library is present with matching version (or no specific version required)
+                result["present"][lib_name] = sw_packages[lib_name]
+
+        if return_full_sw_package_list:
+            # Extract just the library names from required_libraries
+            req_libs_names = [lib.split("==")[0].strip() if "==" in lib else lib.strip() for lib in required_libraries]
+
+            def sort_key(pkg_name):
+                if pkg_name in result["not_present"]:
+                    return (0, pkg_name)  # Missing packages first
+                elif pkg_name in result["version_mismatch"]:
+                    return (1, pkg_name)  # Version mismatch second
+                elif pkg_name in req_libs_names:
+                    return (2, pkg_name)  # Required packages that match third
+                else:
+                    return (3, pkg_name)  # All other packages last
+
+            # Sort sw_packages using the custom sorting key
+            result["sw_packages"] = {k: sw_packages[k] for k in sorted(sw_packages.keys(), key=sort_key)}
+
+            # Add missing packages to the top of sw_packages
+            for pkg in result["not_present"]:
+                result["sw_packages"] = {pkg: None, **result["sw_packages"]}
+
+
+        return result
+
+    def visualize_software_spec(analysis_result, required_libraries=None):
+        """
+        Visualizes the results of analyze_software_spec in a DataFrame with status indicators.
+        For use in Marimo notebooks.
+
+        Args:
+            analysis_result (dict): The result from analyze_software_spec function
+            required_libraries (list, optional): The original list of required libraries
+                                                used in analyze_software_spec
+
+        Returns:
+            pandas.DataFrame: A DataFrame showing the analysis results with status indicators
+        """
+        import pandas as pd
+
+        # Parse required libraries to get the exact names for lookup
+        req_libs_parsed = {}
+        if required_libraries:
+            for lib in required_libraries:
+                if "==" in lib:
+                    lib_name, lib_version = lib.split("==", 1)
+                    lib_name = lib_name.strip()
+                    lib_version = lib_version.strip()
+                    req_libs_parsed[lib_name] = lib_version
+                else:
+                    lib_name = lib.strip()
+                    req_libs_parsed[lib_name] = None
+
+        # Determine if we have the full sw_packages list
+        has_full_list = "sw_packages" in analysis_result
+
+        # Create a DataFrame based on available data
+        if has_full_list:
+            # Use the full package list
+            packages = analysis_result["sw_packages"]
+
+            # Prepare data rows
+            rows = []
+            for package, version in packages.items():
+                if package in analysis_result.get("not_present", {}):
+                    status = "❌ Missing"
+                    priority = 0  # Top priority
+                elif package in analysis_result.get("version_mismatch", {}):
+                    status = "⚠️ Version Mismatch"
+                    priority = 1  # Second priority
+                elif package in req_libs_parsed:
+                    status = "✅ Present"
+                    priority = 2  # Third priority
+                else:
+                    status = "Other"
+                    priority = 3  # Lowest priority
+
+                rows.append({
+                    "Package": package,
+                    "Version": version if version is not None else "Not Present",
+                    "Status": status,
+                    "_priority": priority  # Temporary field for sorting
+                })
+
+            df = pd.DataFrame(rows)
+
+            # Sort by priority and then package name
+            df = df.sort_values(by=["_priority", "Package"]).drop("_priority", axis=1).reset_index(drop=True)
+
+        else:
+            # Only use the packages mentioned in required_libraries
+            packages = set(list(analysis_result.get("not_present", {}).keys()) + 
+                          list(analysis_result.get("version_mismatch", {}).keys()) + 
+                          list(analysis_result.get("present", {}).keys()))
+
+            # Create dataframe rows
+            rows = []
+            for package in packages:
+                if package in analysis_result.get("not_present", {}):
+                    version = "Not Present"
+                    status = "❌ Missing"
+                    priority = 0  # Top priority
+                elif package in analysis_result.get("version_mismatch", {}):
+                    version = analysis_result["version_mismatch"][package][0]  # sw_spec version
+                    status = "⚠️ Version Mismatch"
+                    priority = 1  # Second priority
+                else:
+                    version = analysis_result["present"][package]
+                    status = "✅ Present"
+                    priority = 2  # Third priority
+
+                rows.append({
+                    "Package": package, 
+                    "Version": version, 
+                    "Status": status,
+                    "_priority": priority  # Temporary field for sorting
+                })
+
+            df = pd.DataFrame(rows)
+
+            # Sort by priority and then package name
+            df = df.sort_values(by=["_priority", "Package"]).drop("_priority", axis=1).reset_index(drop=True)
+
+        return df
+    return analyze_software_spec, visualize_software_spec
+
 
 @app.cell
 def _(