remove validation boolean, validate always

Author: jcschaff

libvcell/_internal/native_calls.py

@@ -60,7 +60,7 @@ def sbml_to_finite_volume_input(self, sbml_content: str, output_dir_path: Path)
             raise
 
     def vcml_to_sbml(
-        self, vcml_content: str, application_name: str, sbml_file_path: Path, validate: bool
+        self, vcml_content: str, application_name: str, sbml_file_path: Path
     ) -> ReturnValue:
         try:
             with IsolateManager(self.lib) as isolate_thread:
@@ -69,7 +69,6 @@ def vcml_to_sbml(
                     ctypes.c_char_p(vcml_content.encode("utf-8")),
                     ctypes.c_char_p(application_name.encode("utf-8")),
                     ctypes.c_char_p(str(sbml_file_path).encode("utf-8")),
-                    ctypes.c_int(1 if validate else 0),
                 )
 
             value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value
@@ -83,14 +82,13 @@ def vcml_to_sbml(
             logging.exception("Error in vcml_to_sbml()", exc_info=e)
             raise
 
-    def sbml_to_vcml(self, sbml_content: str, vcml_file_path: Path, validate: bool) -> ReturnValue:
+    def sbml_to_vcml(self, sbml_content: str, vcml_file_path: Path) -> ReturnValue:
         try:
             with IsolateManager(self.lib) as isolate_thread:
                 json_ptr: ctypes.c_char_p = self.lib.sbmlToVcml(
                     isolate_thread,
                     ctypes.c_char_p(sbml_content.encode("utf-8")),
                     ctypes.c_char_p(str(vcml_file_path).encode("utf-8")),
-                    ctypes.c_int(1 if validate else 0),
                 )
 
             value: bytes | None = ctypes.cast(json_ptr, ctypes.c_char_p).value

libvcell/_internal/native_utils.py

@@ -39,10 +39,10 @@ def _define_entry_points(self) -> None:
         self.lib.sbmlToFiniteVolumeInput.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
 
         self.lib.sbmlToVcml.restype = ctypes.c_char_p
-        self.lib.sbmlToVcml.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
+        self.lib.sbmlToVcml.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
 
         self.lib.vcmlToSbml.restype = ctypes.c_char_p
-        self.lib.vcmlToSbml.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int]
+        self.lib.vcmlToSbml.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
 
         self.lib.vcmlToVcml.restype = ctypes.c_char_p
         self.lib.vcmlToVcml.argtypes = [ctypes.c_void_p, ctypes.c_char_p]

libvcell/model_utils.py

@@ -3,38 +3,36 @@
 from libvcell._internal.native_calls import ReturnValue, VCellNativeCalls
 
 
-def vcml_to_sbml(vcml_content: str, application_name: str, sbml_file_path: Path, validate: bool) -> tuple[bool, str]:
+def vcml_to_sbml(vcml_content: str, application_name: str, sbml_file_path: Path) -> tuple[bool, str]:
     """
     Convert VCML content to SBML file
 
     Args:
         vcml_content (str): VCML content
         application_name (str): VCell Biomodel application name
         sbml_file_path (Path): path to resulting SBML file
-        validate (bool): whether to validate SBML file
 
     Returns:
         tuple[bool, str]: A tuple containing the success status and a message
     """
     native = VCellNativeCalls()
-    return_value: ReturnValue = native.vcml_to_sbml(vcml_content, application_name, sbml_file_path, validate)
+    return_value: ReturnValue = native.vcml_to_sbml(vcml_content, application_name, sbml_file_path)
     return return_value.success, return_value.message
 
 
-def sbml_to_vcml(sbml_content: str, vcml_file_path: Path, validate: bool) -> tuple[bool, str]:
+def sbml_to_vcml(sbml_content: str, vcml_file_path: Path) -> tuple[bool, str]:
     """
     Convert SBML content to finite volume input files
 
     Args:
         sbml_content (str): SBML content
         vcml_file_path (Path): path to resulting VCML file
-        validate (bool): whether to validate SBML import with round trip test
 
     Returns:
         tuple[bool, str]: A tuple containing the success status and a message
     """
     native = VCellNativeCalls()
-    return_value: ReturnValue = native.sbml_to_vcml(sbml_content, vcml_file_path, validate)
+    return_value: ReturnValue = native.sbml_to_vcml(sbml_content, vcml_file_path)
     return return_value.success, return_value.message
 
 

tests/test_libvcell.py

@@ -24,7 +24,7 @@ def test_sbml_to_finite_volume_input(temp_output_dir: Path, sbml_file_path: Path
 def test_sbml_to_vcml(temp_output_dir: Path, sbml_file_path: Path) -> None:
     sbml_content = sbml_file_path.read_text()
     vcml_file_path = temp_output_dir / "test.vcml"
-    success, msg = sbml_to_vcml(sbml_content=sbml_content, vcml_file_path=vcml_file_path, validate=False)
+    success, msg = sbml_to_vcml(sbml_content=sbml_content, vcml_file_path=vcml_file_path)
     assert vcml_file_path.exists()
     assert success is True
     assert msg == "Success"
@@ -34,7 +34,7 @@ def test_vcml_to_sbml(temp_output_dir: Path, vcml_file_path: Path, vcml_app_name
     vcml_content = vcml_file_path.read_text()
     sbml_file_path = temp_output_dir / "test.sbml"
     success, msg = vcml_to_sbml(
-        vcml_content=vcml_content, application_name=vcml_app_name, sbml_file_path=sbml_file_path, validate=False
+        vcml_content=vcml_content, application_name=vcml_app_name, sbml_file_path=sbml_file_path
     )
     assert sbml_file_path.exists()
     assert success is True

vcell-native/src/main/java/org/vcell/libvcell/Entrypoints.java

@@ -119,21 +119,19 @@ public static CCharPointer entrypoint_sbmlToFiniteVolumeInput(
                       vcml_content: text of VCML XML document
                       application_name: name of the application to export
                       sbml_file_path: path to the SBML file to write
-                      validate_sbml: whether to validate the SBML file
                       Returns a JSON string with success status and message"""
     )
     public static CCharPointer entrypoint_vcmlToSbml(
             IsolateThread ignoredThread,
             CCharPointer vcml_content,
             CCharPointer application_name,
-            CCharPointer sbml_file_path,
-            int validate_sbml) {
+            CCharPointer sbml_file_path) {
         ReturnValue returnValue;
         try {
             String vcmlContentStr = CTypeConversion.toJavaString(vcml_content);
             String applicationName = CTypeConversion.toJavaString(application_name);
             Path sbmlFilePath = new File(CTypeConversion.toJavaString(sbml_file_path)).toPath();
-            vcml_to_sbml(vcmlContentStr, applicationName, sbmlFilePath, CTypeConversion.toBoolean(validate_sbml));
+            vcml_to_sbml(vcmlContentStr, applicationName, sbmlFilePath);
             returnValue = new ReturnValue(true, "Success");
         }catch (Throwable t) {
             logger.error("Error translating vcml application to sbml", t);
@@ -151,19 +149,17 @@ public static CCharPointer entrypoint_vcmlToSbml(
                     Converts SBML file into a VCML file.
                       sbml_content: text of SBML XML document
                       vcml_file_path: path to the VCML file to write
-                      validate_sbml: whether to validate the SBML file
                       Returns a JSON string with success status and message"""
     )
     public static CCharPointer entrypoint_sbmlToVcml(
             IsolateThread ignoredThread,
             CCharPointer sbml_content,
-            CCharPointer vcml_file_path,
-            int validate_sbml) {
+            CCharPointer vcml_file_path) {
         ReturnValue returnValue;
         try {
             String sbmlContentStr = CTypeConversion.toJavaString(sbml_content);
             Path vcmlFilePath = new File(CTypeConversion.toJavaString(vcml_file_path)).toPath();
-            sbml_to_vcml(sbmlContentStr, vcmlFilePath, CTypeConversion.toBoolean(validate_sbml));
+            sbml_to_vcml(sbmlContentStr, vcmlFilePath);
             returnValue = new ReturnValue(true, "Success");
         }catch (Throwable t) {
             logger.error("Error translating sbml to vcml", t);

vcell-native/src/main/java/org/vcell/libvcell/MainRecorder.java

@@ -54,8 +54,7 @@ public static void main(String[] args) {
 
                 // create a temporary file for the VCML output
                 File temp_vcml_file = new File(output_dir, "temp.vcml");
-                boolean validateSBML = true;
-                sbml_to_vcml(sbml_str, temp_vcml_file.toPath(), validateSBML);
+                sbml_to_vcml(sbml_str, temp_vcml_file.toPath());
                 // remove temporary file
                 if (temp_vcml_file.exists()) {
                     boolean deleted = temp_vcml_file.delete();
@@ -71,8 +70,7 @@ public static void main(String[] args) {
 
                 // create a temporary file for the SBML output
                 File temp_sbml_file = new File(output_dir, "temp.vcml");
-                boolean validateSBML = true;
-                vcml_to_sbml(vcml_str, vcml_app_name, temp_sbml_file.toPath(), validateSBML);
+                vcml_to_sbml(vcml_str, vcml_app_name, temp_sbml_file.toPath());
                 // remove temporary file
                 if (temp_sbml_file.exists()) {
                     boolean deleted = temp_sbml_file.delete();

vcell-native/src/main/java/org/vcell/libvcell/ModelUtils.java

@@ -22,7 +22,7 @@
 
 public class ModelUtils {
 
-    public static void sbml_to_vcml(String sbml_content, Path vcmlPath, boolean validateSBML)
+    public static void sbml_to_vcml(String sbml_content, Path vcmlPath)
             throws VCLoggerException, XmlParseException, IOException, MappingException {
 
         record LoggerMessage(VCLogger.Priority priority, VCLogger.ErrorType errorType, String message) {};
@@ -40,6 +40,7 @@ record LoggerMessage(VCLogger.Priority priority, VCLogger.ErrorType errorType, S
         final BioModel bioModel;
         try (InputStream inputStream = new ByteArrayInputStream(sbml_content.getBytes())) {
             // create a SBMLImporter from the XMLSource
+            boolean validateSBML = true;
             SBMLImporter sbmlImporter = new SBMLImporter(inputStream, vclogger, validateSBML);
             bioModel = sbmlImporter.getBioModel();
         }
@@ -60,12 +61,13 @@ record LoggerMessage(VCLogger.Priority priority, VCLogger.ErrorType errorType, S
     }
 
 
-    public static void vcml_to_sbml(String vcml_content, String applicationName, Path sbmlPath, boolean validateSBML)
+    public static void vcml_to_sbml(String vcml_content, String applicationName, Path sbmlPath)
             throws XmlParseException, IOException, XMLStreamException, SbmlException, MappingException {
 
         BioModel bioModel = XmlHelper.XMLToBioModel(new XMLSource(vcml_content));
         bioModel.updateAll(false);
         SimulationContext simContext = bioModel.getSimulationContext(applicationName);
+        boolean validateSBML = true;
         SBMLExporter sbmlExporter = new SBMLExporter(simContext, 3, 1, validateSBML);
         String sbml_string = sbmlExporter.getSBMLString();
         XmlUtil.writeXMLStringToFile(sbml_string, sbmlPath.toFile().getAbsolutePath(), true);

vcell-native/src/test/java/org/vcell/libvcell/EntrypointsTest.java

@@ -117,8 +117,7 @@ public void test_sbml_to_vcml() throws MappingException, IOException, XmlParseEx
         String sbmlContent = getFileContentsAsString("/TinySpatialProject_Application0.xml");
         File parent_dir = Files.createTempDirectory("sbmlToVcml").toFile();
         File vcml_temp_file = new File(parent_dir, "temp.vcml");
-        boolean validate = true;
-        sbml_to_vcml(sbmlContent, vcml_temp_file.toPath(), validate);
+        sbml_to_vcml(sbmlContent, vcml_temp_file.toPath());
         assert(vcml_temp_file.exists());
     }
 
@@ -128,8 +127,7 @@ public void test_vcml_to_sbml() throws MappingException, IOException, XmlParseEx
         File parent_dir = Files.createTempDirectory("vcmlToSbml").toFile();
         File sbml_temp_file = new File(parent_dir, "temp.sbml");
         String applicationName = "unnamed_spatialGeom";
-        boolean validate = true;
-        vcml_to_sbml(vcmlContent, applicationName, sbml_temp_file.toPath(), validate);
+        vcml_to_sbml(vcmlContent, applicationName, sbml_temp_file.toPath());
         assert(sbml_temp_file.exists());
     }