fix(api): add missing denormalized rules in refactor export_study_fla…

antarest/study/common/studystorage.py

@@ -230,27 +230,6 @@ def export_output(self, metadata: T, output_id: str, target: Path) -> None:
         """
         raise NotImplementedError()
 
-    @abstractmethod
-    def export_study_flat(
-        self,
-        metadata: T,
-        dst_path: Path,
-        outputs: bool = True,
-        output_list_filter: Optional[List[str]] = None,
-        denormalize: bool = True,
-    ) -> None:
-        """
-        Export study to destination
-
-        Args:
-            metadata: study.
-            dst_path: destination path.
-            outputs: list of outputs to keep.
-            output_list_filter: list of outputs to keep (None indicate all outputs).
-            denormalize: denormalize the study (replace matrix links by real matrices).
-        """
-        raise NotImplementedError()
-
     @abstractmethod
     def get_synthesis(self, metadata: T, params: Optional[RequestParameters] = None) -> FileStudyTreeConfigDTO:
         """

antarest/study/service.py

@@ -3,6 +3,7 @@
 import json
 import logging
 import os
+import shutil
 from datetime import datetime, timedelta
 from http import HTTPStatus
 from pathlib import Path
@@ -87,6 +88,7 @@
     StudySimResultDTO,
 )
 from antarest.study.repository import StudyMetadataRepository
+from antarest.study.storage.abstract_storage_service import export_study_flat
 from antarest.study.storage.rawstudy.model.filesystem.config.model import FileStudyTreeConfigDTO
 from antarest.study.storage.rawstudy.model.filesystem.folder_node import ChildNotFoundError
 from antarest.study.storage.rawstudy.model.filesystem.ini_file_node import IniFileNode
@@ -918,7 +920,18 @@ def export_study(
         def export_task(notifier: TaskUpdateNotifier) -> TaskResult:
             try:
                 target_study = self.get_study(uuid)
-                self.storage_service.get_storage(target_study).export_study(target_study, export_path, outputs)
+                storage = self.storage_service.get_storage(target_study)
+                if isinstance(target_study, RawStudy):
+                    storage = cast(RawStudyService, storage)
+                    if target_study.archived:
+                        storage.unarchive(target_study)
+                    try:
+                        storage.export_study(target_study, export_path, outputs)
+                    finally:
+                        if target_study.archived:
+                            shutil.rmtree(target_study.path)
+                else:
+                    storage.export_study(target_study, export_path, outputs)
                 self.file_transfer_manager.set_ready(export_id)
                 return TaskResult(success=True, message=f"Study {uuid} successfully exported")
             except Exception as e:
@@ -1020,10 +1033,34 @@ def export_study_flat(
         study = self.get_study(uuid)
         assert_permission(params.user, study, StudyPermissionType.READ)
         self._assert_study_unarchived(study)
-
-        return self.storage_service.get_storage(study).export_study_flat(
-            study, dest, len(output_list or []) > 0, output_list
-        )
+        path_study = Path(study.path)
+        storage = self.storage_service.get_storage(study)
+        if isinstance(study, RawStudy):
+            storage = cast(RawStudyService, storage)
+            if study.archived:
+                storage.unarchive(study)
+            try:
+                return storage.export_study_flat(
+                    path_study=path_study,
+                    dst_path=dest,
+                    outputs=len(output_list or []) > 0,
+                    output_list_filter=output_list,
+                    output_src_path=None,
+                )
+            finally:
+                if study.archived:
+                    shutil.rmtree(study.path)
+        else:
+            snapshot_path = path_study / "snapshot"
+            output_src_path = path_study / "output"
+            storage = cast(VariantStudyService, storage)
+            return storage.export_study_flat(
+                path_study=snapshot_path,
+                dst_path=dest,
+                outputs=len(output_list or []) > 0,
+                output_list_filter=output_list,
+                output_src_path=output_src_path,
+            )
 
     def delete_study(self, uuid: str, children: bool, params: RequestParameters) -> None:
         """

antarest/study/storage/abstract_storage_service.py

@@ -1,21 +1,26 @@
+import functools
 import logging
+import os
 import shutil
 import tempfile
+import time
+import zipfile
 from abc import ABC
 from pathlib import Path
-from typing import IO, List, Optional, Union
+from typing import IO, List, Optional, Union, Sequence
 from uuid import uuid4
 
 from antarest.core.config import Config
 from antarest.core.exceptions import BadOutputError, StudyOutputNotFoundError
 from antarest.core.interfaces.cache import CacheConstants, ICache
 from antarest.core.model import JSON
-from antarest.core.utils.utils import StopWatch, assert_this, extract_zip, unzip, zip_dir
+from antarest.core.utils.utils import StopWatch, extract_zip, unzip, zip_dir
 from antarest.study.common.studystorage import IStudyStorageService, T
 from antarest.study.common.utils import get_study_information
 from antarest.study.model import (
     PatchOutputs,
     PatchStudy,
+    RawStudy,
     StudyAdditionalData,
     StudyMetadataDTO,
     StudyMetadataPatchDTO,
@@ -32,6 +37,61 @@
 logger = logging.getLogger(__name__)
 
 
+# noinspection PyUnusedLocal
+def _ignore_patterns(path_study: Path, directory: str, contents: Sequence[str]) -> Sequence[str]:
+    return ["output"] if Path(directory) == path_study else []
+
+
+def export_study_flat(
+    path_study: Path,
+    dest: Path,
+    outputs: bool = True,
+    output_list_filter: Optional[List[str]] = None,
+    output_src_path: Optional[Path] = None,
+) -> None:
+    """
+    Export study to destination
+
+    Args:
+        path_study: Study source path
+        dest: Destination path.
+        outputs: List of outputs to keep.
+        output_list_filter: List of outputs to keep (None indicate all outputs).
+        output_src_path: list of source outputs path.
+    """
+    start_time = time.time()
+    output_src_path = output_src_path or path_study / "output"
+    output_dest_path = dest / "output"
+
+    ignore_patterns = functools.partial(_ignore_patterns, path_study)
+    # noinspection PyTypeChecker
+    shutil.copytree(src=path_study, dst=dest, ignore=ignore_patterns)
+    if outputs and output_src_path.is_dir():
+        if output_dest_path.exists():
+            shutil.rmtree(output_dest_path)
+        if output_list_filter is not None:
+            os.mkdir(output_dest_path)
+            for output in output_list_filter:
+                zip_path = output_src_path / f"{output}.zip"
+                if zip_path.exists():
+                    with zipfile.ZipFile(zip_path) as zf:
+                        zf.extractall(output_dest_path / output)
+                else:
+                    shutil.copytree(
+                        src=output_src_path / output,
+                        dst=output_dest_path / output,
+                    )
+        else:
+            shutil.copytree(
+                src=output_src_path,
+                dst=output_dest_path,
+            )
+
+    stop_time = time.time()
+    duration = "{:.3f}".format(stop_time - start_time)
+    logger.info(f"Study {path_study} exported (flat mode) in {duration}s")
+
+
 class AbstractStorageService(IStudyStorageService[T], ABC):
     def __init__(
         self,
@@ -230,7 +290,23 @@ def export_study(self, metadata: T, target: Path, outputs: bool = True) -> Path:
         with tempfile.TemporaryDirectory(dir=self.config.storage.tmp_dir) as tmpdir:
             logger.info(f"Exporting study {metadata.id} to temporary path {tmpdir}")
             tmp_study_path = Path(tmpdir) / "tmp_copy"
-            self.export_study_flat(metadata, tmp_study_path, outputs)
+            if isinstance(metadata, RawStudy):
+                export_study_flat(
+                    path_study=path_study,
+                    dest=tmp_study_path,
+                    outputs=outputs,
+                )
+            else:
+                snapshot_path = path_study / "snapshot"
+                output_src_path = path_study / "output"
+                export_study_flat(
+                    path_study=snapshot_path,
+                    dest=tmp_study_path,
+                    outputs=outputs,
+                    output_src_path=output_src_path,
+                )
+            study = self.study_factory.create_from_fs(tmp_study_path, "", use_cache=False)
+            study.tree.denormalize()
             stopwatch = StopWatch()
             zip_dir(tmp_study_path, target)
             stopwatch.log_elapsed(lambda x: logger.info(f"Study {path_study} exported (zipped mode) in {x}s"))

antarest/study/storage/rawstudy/raw_study_service.py

@@ -16,14 +16,13 @@
 from antarest.core.requests import RequestParameters
 from antarest.core.utils.utils import extract_zip
 from antarest.study.model import DEFAULT_WORKSPACE_NAME, Patch, RawStudy, Study, StudyAdditionalData
-from antarest.study.storage.abstract_storage_service import AbstractStorageService
+from antarest.study.storage.abstract_storage_service import AbstractStorageService, export_study_flat
 from antarest.study.storage.patch_service import PatchService
 from antarest.study.storage.rawstudy.model.filesystem.config.model import FileStudyTreeConfig, FileStudyTreeConfigDTO
 from antarest.study.storage.rawstudy.model.filesystem.factory import FileStudy, StudyFactory
 from antarest.study.storage.rawstudy.model.filesystem.lazy_node import LazyNode
 from antarest.study.storage.utils import (
     create_new_empty_study,
-    export_study_flat,
     fix_study_root,
     get_default_workspace_path,
     is_managed,
@@ -325,28 +324,21 @@ def import_study(self, metadata: RawStudy, stream: IO[bytes]) -> Study:
 
     def export_study_flat(
         self,
-        metadata: RawStudy,
+        path_study: Path,
         dst_path: Path,
         outputs: bool = True,
+        output_src_path: Optional[Path] = None,
         output_list_filter: Optional[List[str]] = None,
-        denormalize: bool = True,
     ) -> None:
-        path_study = Path(metadata.path)
-
-        if metadata.archived:
-            self.unarchive(metadata)
-        try:
-            export_study_flat(
-                path_study,
-                dst_path,
-                self.study_factory,
-                outputs,
-                output_list_filter,
-                denormalize,
-            )
-        finally:
-            if metadata.archived:
-                shutil.rmtree(metadata.path)
+        export_study_flat(
+            path_study=path_study,
+            dest=dst_path,
+            outputs=outputs,
+            output_list_filter=output_list_filter,
+            output_src_path=output_src_path,
+        )
+        study = self.study_factory.create_from_fs(dst_path, "", use_cache=False)
+        study.tree.denormalize()
 
     def check_errors(
         self,

antarest/study/storage/utils.py

@@ -326,50 +326,3 @@ def get_start_date(
         first_week_size=first_week_size,
         level=level,
     )
-
-
-def export_study_flat(
-    path_study: Path,
-    dest: Path,
-    study_factory: StudyFactory,
-    outputs: bool = True,
-    output_list_filter: Optional[List[str]] = None,
-    denormalize: bool = True,
-    output_src_path: Optional[Path] = None,
-) -> None:
-    start_time = time.time()
-
-    output_src_path = output_src_path or path_study / "output"
-    output_dest_path = dest / "output"
-    ignore_patterns = lambda directory, contents: ["output"] if str(directory) == str(path_study) else []
-
-    shutil.copytree(src=path_study, dst=dest, ignore=ignore_patterns)
-
-    if outputs and output_src_path.exists():
-        if output_list_filter is None:
-            # Retrieve all directories or ZIP files without duplicates
-            output_list_filter = list(
-                {f.with_suffix("").name for f in output_src_path.iterdir() if f.is_dir() or f.suffix == ".zip"}
-            )
-        # Copy each folder or uncompress each ZIP file to the destination dir.
-        shutil.rmtree(output_dest_path, ignore_errors=True)
-        output_dest_path.mkdir()
-        for output in output_list_filter:
-            zip_path = output_src_path / f"{output}.zip"
-            if zip_path.exists():
-                with ZipFile(zip_path) as zf:
-                    zf.extractall(output_dest_path / output)
-            else:
-                shutil.copytree(
-                    src=output_src_path / output,
-                    dst=output_dest_path / output,
-                )
-
-    stop_time = time.time()
-    duration = "{:.3f}".format(stop_time - start_time)
-    logger.info(f"Study {path_study} exported (flat mode) in {duration}s")
-    study = study_factory.create_from_fs(dest, "", use_cache=False)
-    if denormalize:
-        study.tree.denormalize()
-        duration = "{:.3f}".format(time.time() - stop_time)
-        logger.info(f"Study {path_study} denormalized in {duration}s")