feat: Import from project - Improved IO Management

.github/workflows/pr.yml

@@ -18,7 +18,6 @@ jobs:
       uses: "./.github/workflows/lint"
 
   Test:
-    needs: Lint
     strategy:
       fail-fast: false
       matrix:

gudpy/core/container.py

@@ -71,7 +71,7 @@ def __init__(self, config=None):
         """
         self.name = ""
         self.periodNumber = 1
-        self.dataFiles = DataFiles([], "CONTAINER")
+        self.dataFiles = DataFiles([], "CONTAINER", True)
         self.composition = Composition("CONTAINER")
         self.geometry = Geometry.SameAsBeam
         self.upstreamThickness = 0.1
@@ -97,6 +97,7 @@ def __init__(self, config=None):
         self.grBroadening = 0.
         self.powerForBroadening = 0.0
         self.stepSize = 0.0
+        self.outputFolder = ""
 
         self.yamlignore = {
             "runAsSample",

gudpy/core/data_files.py

@@ -1,4 +1,56 @@
+import os
+
 from core import config
+from core import utils
+from core.gud_file import GudFile
+
+
+class DataFile:
+    def __init__(self, filename, isSampleDataFile: bool = False):
+        self.filename = filename
+        self.name = utils.replace_unwanted_chars(
+            os.path.splitext(filename)[0]
+        )
+        self.ext = os.path.splitext(filename)[1]
+        self.outputFolder = ""
+        self._outputs = {}
+        self.isSampleDataFile = isSampleDataFile
+
+        self.yamlignore = {
+            "str",
+            "yamlignore"
+        }
+
+    def addOutput(self, path):
+        ext = os.path.splitext(path)[1]
+        self._outputs[ext] = path
+
+    def outputs(self, ext):
+        return self._outputs[ext]
+
+    def __str__(self):
+        return self.filename
+
+    @property
+    def gudFile(self):
+        if not self.isSampleDataFile:
+            return None
+        gudPath = self._outputs.get(".gud", None)
+        if not gudPath:
+            return None
+        return GudFile(gudPath)
+
+    @property
+    def mintFile(self):
+        if not self.isSampleDataFile:
+            return None
+        return self._outputs.get(".mint01", None)
+
+    @property
+    def msubwFile(self):
+        if not self.isSampleDataFile:
+            return None
+        return self._outputs.get(".msubw01", None)
 
 
 class DataFiles:
@@ -17,7 +69,7 @@ class DataFiles:
     -------
     """
 
-    def __init__(self, dataFiles, name):
+    def __init__(self, dataFiles, name, isSampleDataFile=False):
         """
         Constructs all the necessary attributes for the DataFiles object.
 
@@ -28,14 +80,28 @@ def __init__(self, dataFiles, name):
         name : str
             Name of the parent of the data files, e.g. Sample Background
         """
-        self.dataFiles = dataFiles
+
+        self._dataFiles: DataFile = []
+        self.isSampleDataFile = isSampleDataFile
+        self.setFiles(dataFiles)
+
         self.name = name
 
         self.yamlignore = {
             "str",
             "yamlignore"
         }
 
+        self.outputFolders = {}
+        self._outputs = {}
+
+    def setFiles(self, dataFilenames):
+        self._dataFiles.clear()
+        for dataFile in dataFilenames:
+            if not dataFile:
+                continue
+            self._dataFiles.append(DataFile(dataFile, self.isSampleDataFile))
+
     def __str__(self):
         """
         Returns the string representation of the DataFiles object.
@@ -50,11 +116,20 @@ def __str__(self):
             String representation of DataFiles.
         """
         self.str = [
-            df + config.spc10 + self.name + " data files"
-            for df in self.dataFiles
+            df.filename + config.spc10 + self.name + " data files"
+            for df in self._dataFiles
         ]
         return """\n""".join(self.str)
 
+    @property
+    def dataFilenames(self):
+        dfNames = [df.filename for df in self._dataFiles]
+        return dfNames
+
+    @property
+    def dataFiles(self):
+        return self._dataFiles
+
     def __len__(self):
         """
         Returns the length of the dataFiles list member.
@@ -68,15 +143,15 @@ def __len__(self):
         int
             Number of data files,
         """
-        return len(self.dataFiles)
+        return len(self._dataFiles)
 
     def __getitem__(self, n):
-        return self.dataFiles[n]
+        return self._dataFiles[n]
 
     def __setitem__(self, n, item):
         if n >= len(self):
-            self.dataFiles.extend(n+1)
-        self.dataFiles[n] = item
+            self._dataFiles.extend(n+1)
+        self._dataFiles[n] = DataFile(item)
 
     def __iter__(self):
-        return iter(self.dataFiles)
+        return iter(self._dataFiles)

gudpy/core/file_library.py

@@ -1,9 +1,9 @@
 import os
 from zipfile import ZipFile, ZIP_DEFLATED
-from pathlib import Path
 
 from core import utils
 from core.enums import CrossSectionSource
+from core.io.gudpy_io import GudPyIO
 
 
 class GudPyFileLibrary:
@@ -64,8 +64,8 @@ def __init__(self, gudrunFile):
         }
 
         self.dataFiles = [
-            *gudrunFile.normalisation.dataFiles.dataFiles,
-            *gudrunFile.normalisation.dataFilesBg.dataFiles,
+            *gudrunFile.normalisation.dataFiles.dataFilenames,
+            *gudrunFile.normalisation.dataFilesBg.dataFilenames,
         ]
 
         # If NXS files are being used
@@ -90,15 +90,15 @@ def __init__(self, gudrunFile):
         # that file too.
 
         for sampleBackground in gudrunFile.sampleBackgrounds:
-            self.dataFiles.extend(sampleBackground.dataFiles.dataFiles)
+            self.dataFiles.extend(sampleBackground.dataFiles.dataFilenames)
 
             for sample in sampleBackground.samples:
-                self.dataFiles.extend(sample.dataFiles.dataFiles)
+                self.dataFiles.extend(sample.dataFiles.dataFilenames)
                 if sample.totalCrossSectionSource == CrossSectionSource.FILE:
                     self.files[sample.name] = sample.crossSectionFilename
 
                 for container in sample.containers:
-                    self.dataFiles.extend(container.dataFiles.dataFiles)
+                    self.dataFiles.extend(container.dataFiles.dataFilenames)
                     if container.totalCrossSectionSource == (
                         CrossSectionSource.FILE
                     ):
@@ -166,21 +166,16 @@ def checkFilesExist(self):
     def exportMintData(
         self,
         samples,
+        exportTo="",
         renameDataFiles=False,
-        exportTo=None,
         includeParams=False,
     ):
-        if not exportTo:
-            exportTo = os.path.join(
-                self.gudrunFile.projectDir,
-                Path(self.gudrunFile.path()).stem + ".zip",
-            )
         with ZipFile(exportTo, "w", ZIP_DEFLATED) as zipFile:
             for sample in samples:
                 if len(sample.dataFiles.dataFiles):
                     path = os.path.join(
                         self.gudrunFile.projectDir,
-                        sample.dataFiles.dataFiles[0].replace(
+                        sample.dataFiles.dataFilenames[0].replace(
                             self.gudrunFile.instrument.dataFileType, "mint01"
                         ),
                     )
@@ -199,10 +194,10 @@ def exportMintData(
                             self.gudrunFile.projectDir,
                             safeSampleName + ".sample",
                         )
+                        sample.sampleFile = path
+
                         if not os.path.exists(path):
-                            sample.write_out(
-                                self.gudrunFile.projectDir
-                            )
+                            GudPyIO.writeObject(sample, path)
                         zipFile.write(path, arcname=os.path.basename(path))
 
             return zipFile.filename

gudpy/core/gud_file.py

@@ -71,13 +71,6 @@ class GudFile:
         Contents of the .gud file.
     output : str
         Output for use in the GUI.
-    Methods
-    -------
-    parse():
-        Parses the GudFile from path, assigning values
-        to each of the attributes.
-    write_out(overwrite=False)
-        Writes out the string representation of the GudFile to a file.
     """
 
     def __init__(self, path):
@@ -350,22 +343,3 @@ def __str__(self):
             f'{self.suggestedTweakFactor}\n'
 
         )
-
-    def write_out(self, path):
-        """
-        Writes out the string representation of the GudFile.
-        If 'overwrite' is True, then the initial file is overwritten.
-        Otherwise, it is written to 'gudpy_{initial filename}.gud'.
-
-        Parameters
-        ----------
-        overwrite : bool, optional
-            Overwrite the initial file? (default is False).
-
-        Returns
-        -------
-        None
-        """
-        f = open(path, "w", encoding="utf-8")
-        f.write(str(self))
-        f.close()