Project adjustments (#190)

* minor adjustments

* fix to create

* slight renaming

* set created when project is loaded

* pr response

* ruff

* change test comparing files

* test file changes

Author: andped10

src/easyreflectometry/project.py

@@ -22,7 +22,7 @@
 class Project:
     def __init__(self):
         self._info = self._default_info()
-        self._path = Path(os.path.expanduser('~'))
+        self._path_project_parent = Path(os.path.expanduser('~'))
         self._models = ModelCollection(populate_if_none=False, unique_name='project_models')
         self._materials = MaterialCollection(populate_if_none=False, unique_name='project_materials')
         self._calculator = None
@@ -32,8 +32,8 @@ def __init__(self):
         self._report = None
 
         # Project flags
-        self._project_created = False
-        self._project_with_experiments = False
+        self._created = False
+        self._with_experiments = False
 
     def reset(self):
         del self._models
@@ -44,24 +44,27 @@ def reset(self):
         self._materials = MaterialCollection(populate_if_none=False, unique_name='project_materials')
 
         self._info = self._default_info()
-        self._path = Path(os.path.expanduser('~'))
+        self._path_project_parent = Path(os.path.expanduser('~'))
         self._calculator = None
         self._minimizer = None
         self._experiments = None
         self._colors = None
         self._report = None
 
         # Project flags
-        self._project_created = False
-        self._project_with_experiments = False
+        self._created = False
+        self._with_experiments = False
+
+    @property
+    def created(self) -> bool:
+        return self._created
 
     @property
     def path(self):
-        return self._path
+        return self._path_project_parent / self._info['name']
 
-    @path.setter
-    def path(self, path: Union[Path, str]):
-        self._path = Path(path)
+    def set_path_project_parent(self, path: Union[Path, str]):
+        self._path_project_parent = Path(path)
 
     @property
     def models(self) -> ModelCollection:
@@ -90,7 +93,7 @@ def experiments(self, experiments: List[DataSet1D]) -> None:
 
     @property
     def path_json(self):
-        return self._path / 'project.json'
+        return self.path / 'project.json'
 
     def default_model(self):
         self._replace_collection(MaterialCollection(), self._materials)
@@ -132,26 +135,28 @@ def _default_info(self):
             modified=datetime.datetime.now().strftime('%d.%m.%Y %H:%M'),
         )
 
-    def create_project_dir(self):
-        if not os.path.exists(self._path):
-            os.makedirs(self._path)
-            os.makedirs(self._path / 'experiments')
+    def create(self):
+        if not os.path.exists(self.path):
+            os.makedirs(self.path)
+            os.makedirs(self.path / 'experiments')
+            self._created = True
+            self._timestamp_modification()
         else:
-            print(f'ERROR: Directory {self._path} already exists')
+            print(f'ERROR: Directory {self.path} already exists')
 
-    def save_project_json(self, overwrite=False):
-        if self.path_json.exists() and not overwrite:
+    def save_as_json(self, overwrite=False):
+        if self.path_json.exists() and overwrite:
             print(f'File already exists {self.path_json}. Overwriting...')
             self.path_json.unlink()
         try:
             project_json = json.dumps(self.as_dict(include_materials_not_in_model=True), indent=4)
             self.path_json.parent.mkdir(exist_ok=True, parents=True)
-            with open(self.path_json, 'w') as file:
+            with open(self.path_json, mode='x') as file:
                 file.write(project_json)
         except Exception as exception:
             print(exception)
 
-    def load_project_json(self, path: Optional[Union[Path, str]] = None):
+    def load_from_json(self, path: Optional[Union[Path, str]] = None):
         path = Path(path)
         if path is None:
             path = self.path_json
@@ -160,20 +165,20 @@ def load_project_json(self, path: Optional[Union[Path, str]] = None):
                 project_dict = json.load(file)
                 self.reset()
                 self.from_dict(project_dict)
-            self._path = path.parent
+            self._path_project_parent = path.parents[1]
+            self._created = True
         else:
             print(f'ERROR: File {path} does not exist')
 
     def as_dict(self, include_materials_not_in_model=False):
         project_dict = {}
         project_dict['info'] = self._info
-        project_dict['project_with_experiments'] = self._project_with_experiments
-        project_dict['project_created'] = self._project_created
+        project_dict['with_experiments'] = self._with_experiments
         if self._models is not None:
             project_dict['models'] = self._models.as_dict(skip=['interface'])
         if include_materials_not_in_model:
             self._as_dict_add_materials_not_in_model_dict(project_dict)
-        if self._project_with_experiments:
+        if self._with_experiments:
             self._as_dict_add_experiments(project_dict)
         if self._minimizer is not None:
             project_dict['minimizer'] = self._minimizer.name
@@ -206,7 +211,7 @@ def _as_dict_add_experiments(self, project_dict: dict):
     def from_dict(self, project_dict: dict):
         keys = list(project_dict.keys())
         self._info = project_dict['info']
-        self._project_with_experiments = project_dict['project_with_experiments']
+        self._with_experiments = project_dict['with_experiments']
         if 'models' in keys:
             self._models = None
             self._models = ModelCollection.from_dict(project_dict['models'])
@@ -259,3 +264,6 @@ def _replace_collection(self, src_collection: BaseCollection, dst_collection: Ba
 
         for element in src_collection:
             dst_collection.append(element)
+
+    def _timestamp_modification(self):
+        self._info['modified'] = datetime.datetime.now().strftime('%d.%m.%Y %H:%M')

tests/test_project.py

@@ -25,15 +25,15 @@ def test_constructor(self):
             'experiments': 'None',
             'modified': datetime.datetime.now().strftime('%d.%m.%Y %H:%M'),
         }
-        assert project._path == Path(os.path.expanduser('~'))
+        assert project._path_project_parent == Path(os.path.expanduser('~'))
         assert len(project._materials) == 0
         assert len(project._models) == 0
         assert project._calculator is None
         assert project._minimizer is None
         assert project._experiments is None
         assert project._report is None
-        assert project._project_created is False
-        assert project._project_with_experiments is False
+        assert project._created is False
+        assert project._with_experiments is False
 
     def test_reset(self):
         # When
@@ -45,9 +45,9 @@ def test_reset(self):
         project._minimizer = 'minimizer'
         project._experiments = 'experiments'
         project._report = 'report'
-        project._project_created = True
-        project._project_with_experiments = True
-        project._path = 'project_path'
+        project._created = True
+        project._with_experiments = True
+        project._path_project_parent = 'project_path'
 
         # Then
         project.reset()
@@ -65,13 +65,13 @@ def test_reset(self):
         assert project._materials.unique_name == 'project_materials'
         assert len(project._materials) == 0
 
-        assert project._path == Path(os.path.expanduser('~'))
+        assert project._path_project_parent == Path(os.path.expanduser('~'))
         assert project._calculator is None
         assert project._minimizer is None
         assert project._experiments is None
         assert project._report is None
-        assert project._project_created is False
-        assert project._project_with_experiments is False
+        assert project._created is False
+        assert project._with_experiments is False
         assert global_object.map.vertices() == ['project_models', 'project_materials']
 
     def test_models(self):
@@ -132,10 +132,10 @@ def test_experiments(self):
     def test_path_json(self, tmp_path):
         # When
         project = Project()
-        project.path = tmp_path
+        project.set_path_project_parent(tmp_path)
 
         # Then Expect
-        assert project.path_json == Path(tmp_path) / 'project.json'
+        assert project.path_json == Path(tmp_path) / 'Example Project' / 'project.json'
 
     def test_add_material(self):
         # When
@@ -203,8 +203,7 @@ def test_as_dict(self):
         assert keys == [
             'info',
             'models',
-            'project_created',
-            'project_with_experiments',
+            'with_experiments',
         ]
         assert project_dict['info'] == {
             'name': 'Example Project',
@@ -214,8 +213,7 @@ def test_as_dict(self):
             'modified': datetime.datetime.now().strftime('%d.%m.%Y %H:%M'),
         }
         assert project_dict['models']['data'] == []
-        assert project_dict['project_created'] is False
-        assert project_dict['project_with_experiments'] is False
+        assert project_dict['with_experiments'] is False
 
     def test_as_dict_models(self):
         # When
@@ -315,41 +313,104 @@ def test_dict_round_trip(self):
             assert project_dict[key] == new_project_dict[key]
         assert project_materials_dict == new_project_materials_dict
 
-    def test_save_project(self, tmp_path):
+    def test_save_as_json(self, tmp_path):
         # When
         global_object.map._clear()
         project = Project()
-        project.path = tmp_path
+        project.set_path_project_parent(tmp_path)
         project._models.append(Model())
         project._info['name'] = 'Test Project'
-        project.save_project_json(overwrite=True)
 
         # Then
-        project_path = project.path_json
+        project.save_as_json()
+        project.path_json
 
         # Expect
-        assert project_path.exists()
+        assert project.path_json.exists()
 
-    def test_load_project(self, tmp_path):
+    def test_save_as_json_overwrite(self, tmp_path):
         # When
         global_object.map._clear()
         project = Project()
-        project.path = tmp_path
+        project.set_path_project_parent(tmp_path)
+        project.save_as_json()
+        file_info = project.path_json.stat()
+
+        # Then
+        project._info['short_description'] = 'short_description'
         project._models.append(Model())
-        project._info['name'] = 'Test Project'
-        project.save_project_json()
+        project.save_as_json(overwrite=True)
+
+        # Expect
+        assert str(file_info) != str(project.path_json.stat())
+
+    def test_save_as_json_dont_overwrite(self, tmp_path):
+        # When
+        global_object.map._clear()
+        project = Project()
+        project.set_path_project_parent(tmp_path)
+        project.save_as_json()
+        file_info = project.path_json.stat()
+
+        # Then
+        project._info['short_description'] = 'short_description'
+        project._models.append(Model())
+        project.save_as_json()
+
+        # Expect
+        assert str(file_info) == str(project.path_json.stat())
+
+    def test_load_from_json(self, tmp_path):
+        # When
+        global_object.map._clear()
+        project = Project()
+        project.set_path_project_parent(tmp_path)
+        project._models.append(Model())
+        project._info['name'] = 'name'
+        project._info['short_description'] = 'short_description'
+        project._info['samples'] = 'samples'
+        project._info['experiments'] = 'experiments'
+
+        project.save_as_json()
         project_dict = project.as_dict()
 
         global_object.map._clear()
         new_project = Project()
 
         # Then
-        new_project.load_project_json(tmp_path / 'project.json')
+        new_project.load_from_json(tmp_path / 'name' / 'project.json')
         # Do it twice to ensure that potential global objects don't collide
-        new_project.load_project_json(tmp_path / 'project.json')
+        new_project.load_from_json(tmp_path / 'name' / 'project.json')
 
         # Expect
         assert len(new_project._models) == 1
-        assert new_project._info['name'] == 'Test Project'
-        assert new_project.as_dict() == project_dict
-        assert new_project.path == tmp_path
+        assert new_project._info['name'] == 'name'
+        assert new_project._info['short_description'] == 'short_description'
+        assert new_project._info['samples'] == 'samples'
+        assert new_project._info['experiments'] == 'experiments'
+        assert project_dict == new_project.as_dict()
+        assert new_project._path_project_parent == tmp_path
+        assert new_project.created is True
+
+    def test_create(self, tmp_path):
+        # When
+        project = Project()
+        project.set_path_project_parent(tmp_path)
+        project._info['modified'] = 'modified'
+        project._info['name'] = 'Test Project'
+
+        # Then
+        project.create()
+
+        # Expect
+        assert project.path == tmp_path / 'Test Project'
+        assert project.path.exists()
+        assert (project.path / 'experiments').exists()
+        assert project.created is True
+        assert project._info == {
+            'name': 'Test Project',
+            'short_description': 'reflectometry, 1D',
+            'samples': 'None',
+            'experiments': 'None',
+            'modified': datetime.datetime.now().strftime('%d.%m.%Y %H:%M'),
+        }