feat(raw-api): add an endpoint to retrieve files in their original format

antarest/core/exceptions.py

@@ -688,6 +688,11 @@ def __init__(self, message: str) -> None:
         super().__init__(HTTPStatus.NOT_FOUND, message)
 
 
+class PathIsAFolderError(HTTPException):
+    def __init__(self, message: str) -> None:
+        super().__init__(HTTPStatus.UNPROCESSABLE_ENTITY, message)
+
+
 class WorkspaceNotFound(HTTPException):
     """
     This will be raised when we try to load a workspace that does not exist

antarest/core/swagger.py

@@ -10,9 +10,10 @@
 #
 # This file is part of the Antares project.
 
-from typing import Any, List, Tuple
+import typing as t
 
 from fastapi import FastAPI
+from fastapi.openapi.models import Example
 from fastapi.routing import APIRoute
 
 sim = "{sim} = simulation index <br/>"
@@ -21,7 +22,7 @@
 attachment = "User-defined file attachment <br/>"
 
 # noinspection SpellCheckingInspection
-urls: List[Tuple[str, str]] = [
+urls: t.List[t.Tuple[str, str]] = [
     ("layers/layers", ""),
     ("settings/generaldata", ""),
     ("output/{sim}/about-the-study/parameters", sim),
@@ -41,7 +42,7 @@
 ]
 
 
-def get_path_examples() -> Any:
+def get_path_examples() -> t.Dict[str, Example]:
     return {url: {"value": url, "description": des} for url, des in urls}
 
 

antarest/core/utils/archives.py

@@ -145,7 +145,7 @@ def extract_file_to_tmp_dir(archive_path: Path, inside_archive_path: Path) -> t.
     return path, tmp_dir
 
 
-def read_file_from_archive(archive_path: Path, posix_path: str) -> str:
+def read_original_file_in_archive(archive_path: Path, posix_path: str) -> bytes:
     """
     Read a file from an archive.
 
@@ -154,21 +154,36 @@ def read_file_from_archive(archive_path: Path, posix_path: str) -> str:
         posix_path: path to the file inside the archive.
 
     Returns:
-        The content of the file as a string.
+        The content of the file as `bytes`.
     """
 
     if archive_path.suffix == ArchiveFormat.ZIP:
         with zipfile.ZipFile(archive_path) as zip_obj:
             with zip_obj.open(posix_path) as f:
-                return f.read().decode("utf-8")
+                return f.read()
     elif archive_path.suffix == ArchiveFormat.SEVEN_ZIP:
         with py7zr.SevenZipFile(archive_path, mode="r") as szf:
-            file_text: str = szf.read([posix_path])[posix_path].read().decode("utf-8")
-            return file_text
+            output: bytes = szf.read([posix_path])[posix_path].read()
+            return output
     else:
         raise ValueError(f"Unsupported {archive_path.suffix} archive format for {archive_path}")
 
 
+def read_file_from_archive(archive_path: Path, posix_path: str) -> str:
+    """
+    Read a file from an archive.
+
+    Args:
+        archive_path: the path to the archive file.
+        posix_path: path to the file inside the archive.
+
+    Returns:
+        The content of the file as a string.
+    """
+
+    return read_original_file_in_archive(archive_path, posix_path).decode("utf-8")
+
+
 def extract_lines_from_archive(root: Path, posix_path: str) -> t.List[str]:
     """
     Extract text lines from various types of files.

antarest/study/business/matrix_management.py

@@ -252,10 +252,7 @@ def update_matrix(
 
         try:
             logger.info(f"Loading matrix data from node '{path}'...")
-            matrix_df = cast(
-                pd.DataFrame,
-                matrix_node.parse(return_dataframe=True),
-            )
+            matrix_df = matrix_node.parse_as_dataframe()
         except ValueError as exc:
             raise MatrixManagerError(f"Cannot parse matrix: {exc}") from exc
 

antarest/study/common/studystorage.py

@@ -20,6 +20,7 @@
 from antarest.study.model import Study, StudyMetadataDTO, StudyMetadataPatchDTO, StudySimResultDTO
 from antarest.study.storage.rawstudy.model.filesystem.config.model import FileStudyTreeConfigDTO
 from antarest.study.storage.rawstudy.model.filesystem.factory import FileStudy
+from antarest.study.storage.rawstudy.model.filesystem.inode import OriginalFile
 
 T = t.TypeVar("T", bound=Study)
 
@@ -56,6 +57,23 @@ def get(
 
         """
 
+    @abstractmethod
+    def get_file(
+        self,
+        metadata: T,
+        url: str = "",
+    ) -> OriginalFile:
+        """
+        Entry point to fetch for a specific file inside a study folder
+
+        Args:
+            metadata: study
+            url: path data inside study to reach the file
+
+        Returns: study file content and extension
+
+        """
+
     @abstractmethod
     def exists(self, metadata: T) -> bool:
         """

antarest/study/service.py

@@ -134,7 +134,7 @@
 from antarest.study.storage.matrix_profile import adjust_matrix_columns_index
 from antarest.study.storage.rawstudy.model.filesystem.config.model import FileStudyTreeConfigDTO
 from antarest.study.storage.rawstudy.model.filesystem.ini_file_node import IniFileNode
-from antarest.study.storage.rawstudy.model.filesystem.inode import INode
+from antarest.study.storage.rawstudy.model.filesystem.inode import INode, OriginalFile
 from antarest.study.storage.rawstudy.model.filesystem.matrix.input_series_matrix import InputSeriesMatrix
 from antarest.study.storage.rawstudy.model.filesystem.matrix.matrix import MatrixFrequency
 from antarest.study.storage.rawstudy.model.filesystem.matrix.output_series_matrix import OutputSeriesMatrix
@@ -451,6 +451,30 @@ def get(
 
         return self.storage_service.get_storage(study).get(study, url, depth, formatted)
 
+    def get_file(
+        self,
+        uuid: str,
+        url: str,
+        params: RequestParameters,
+    ) -> OriginalFile:
+        """
+        retrieve a file from a study folder
+
+        Args:
+            uuid: study uuid
+            url: route to follow inside study structure
+            params: request parameters
+
+        Returns: data study formatted in json
+
+        """
+        study = self.get_study(uuid)
+        assert_permission(params.user, study, StudyPermissionType.READ)
+
+        output = self.storage_service.get_storage(study).get_file(study, url)
+
+        return output
+
     def aggregate_output_data(
         self,
         uuid: str,

antarest/study/storage/abstract_storage_service.py

@@ -18,8 +18,6 @@
 from pathlib import Path
 from uuid import uuid4
 
-import py7zr
-
 from antarest.core.config import Config
 from antarest.core.exceptions import BadOutputError, StudyOutputNotFoundError
 from antarest.core.interfaces.cache import CacheConstants, ICache
@@ -45,6 +43,7 @@
 from antarest.study.storage.rawstudy.model.filesystem.config.files import get_playlist
 from antarest.study.storage.rawstudy.model.filesystem.config.model import Simulation
 from antarest.study.storage.rawstudy.model.filesystem.factory import FileStudy, StudyFactory
+from antarest.study.storage.rawstudy.model.filesystem.inode import OriginalFile
 from antarest.study.storage.rawstudy.model.helpers import FileStudyHelpers
 from antarest.study.storage.utils import extract_output_name, fix_study_root, remove_from_cache
 
@@ -171,6 +170,30 @@ def get(
         del study
         return data
 
+    def get_file(
+        self,
+        metadata: T,
+        url: str = "",
+        use_cache: bool = True,
+    ) -> OriginalFile:
+        """
+        Entry point to fetch data inside study.
+        Args:
+            metadata: study
+            url: path data inside study to reach
+            use_cache: indicate if the cache must be used
+
+        Returns: a file content with its extension and name
+
+        """
+        self._check_study_exists(metadata)
+        study = self.get_raw(metadata, use_cache)
+        parts = [item for item in url.split("/") if item]
+
+        file_node = study.tree.get_node(parts)
+
+        return file_node.get_file_content()
+
     def get_study_sim_result(
         self,
         study: T,

antarest/study/storage/rawstudy/model/filesystem/folder_node.py

@@ -14,11 +14,11 @@
 import typing as t
 from abc import ABC, abstractmethod
 
-from antarest.core.exceptions import ChildNotFoundError
+from antarest.core.exceptions import ChildNotFoundError, PathIsAFolderError
 from antarest.core.model import JSON, SUB_JSON
 from antarest.study.storage.rawstudy.model.filesystem.config.model import FileStudyTreeConfig
 from antarest.study.storage.rawstudy.model.filesystem.context import ContextServer
-from antarest.study.storage.rawstudy.model.filesystem.inode import TREE, INode
+from antarest.study.storage.rawstudy.model.filesystem.inode import TREE, INode, OriginalFile
 
 
 class FilterError(Exception):
@@ -216,3 +216,7 @@ def extract_child(self, children: TREE, url: t.List[str]) -> t.Tuple[t.List[str]
             if not isinstance(children[name], child_class):
                 raise FilterError("Filter selection has different classes")
         return names, sub_url
+
+    def get_file_content(self) -> OriginalFile:
+        relative_path = self.config.path.relative_to(self.config.study_path).as_posix()
+        raise PathIsAFolderError(f"Node at {relative_path} is a folder node.")

antarest/study/storage/rawstudy/model/filesystem/inode.py

@@ -11,18 +11,26 @@
 # This file is part of the Antares project.
 
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, Generic, List, Optional, Tuple, TypeVar
 
 from antarest.core.exceptions import WritingInsideZippedFileException
-from antarest.core.utils.archives import extract_file_to_tmp_dir
+from antarest.core.utils.archives import extract_file_to_tmp_dir, read_original_file_in_archive
 from antarest.study.storage.rawstudy.model.filesystem.config.model import FileStudyTreeConfig
 
 G = TypeVar("G")
 S = TypeVar("S")
 V = TypeVar("V")
 
 
+@dataclass
+class OriginalFile:
+    suffix: str
+    content: bytes
+    filename: str
+
+
 class INode(ABC, Generic[G, S, V]):
     """
     Abstract tree element, have to be implemented to create hub or left.
@@ -124,6 +132,21 @@ def denormalize(self) -> None:
         """
         raise NotImplementedError()
 
+    def get_file_content(self) -> OriginalFile:
+        suffix = self.config.path.suffix
+        filename = self.config.path.name
+        if self.config.archive_path:
+            content = read_original_file_in_archive(
+                self.config.archive_path,
+                self.get_relative_path_inside_archive(self.config.archive_path),
+            )
+            return OriginalFile(suffix=suffix, filename=filename, content=content)
+        else:
+            return OriginalFile(content=self.config.path.read_bytes(), suffix=suffix, filename=filename)
+
+    def get_relative_path_inside_archive(self, archive_path: Path) -> str:
+        return self.config.path.relative_to(archive_path.parent / self.config.study_id).as_posix()
+
     def _assert_url_end(self, url: Optional[List[str]] = None) -> None:
         """
         Raise error if elements remain in url

antarest/study/storage/rawstudy/model/filesystem/lazy_node.py

@@ -9,7 +9,6 @@
 # SPDX-License-Identifier: MPL-2.0
 #
 # This file is part of the Antares project.
-
 import typing as t
 from abc import ABC, abstractmethod
 from dataclasses import dataclass