oceanprotocol-job-details 0.0.8__tar.gz → 0.0.10__tar.gz

oceanprotocol_job_details-0.0.10/.gitignore

@@ -0,0 +1,6 @@
+.env
+dist
+
+*egg-info
+__pycache__
+.pytest_cache

oceanprotocol_job_details-0.0.10/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: oceanprotocol-job-details
+Version: 0.0.10
+Summary: A Python package to get details from OceanProtocol jobs
+Project-URL: Homepage, https://github.com/AgrospAI/oceanprotocol-job-details
+Project-URL: Issues, https://github.com/AgrospAI/oceanprotocol-job-details/issues
+Author-email: Christian López García <christian.lopez@udl.cat>
+License: Copyright 2025 Agrospai
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: orjson>=3.10.15
+Requires-Dist: pydantic>=2.10.6
+Requires-Dist: pytest<9,>=8.3.4
+Description-Content-Type: text/markdown
+
+A Python package to get details from OceanProtocol jobs
+
+---
+
+## Installation
+
+```
+pip install oceanprotocol-job-details
+```
+
+## Usage 
+
+As a simple library, we only need to import the main object and use it once:
+
+```Python
+from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
+
+# Using default parameters
+job_details = OceanProtocolJobDetails().load()
+```
+
+Assumes the following directory structure:
+```
+<ROOT_FOLDER>
+└───data
+    ├───ddos
+    ├───inputs
+    └───logs
+```
+
+### Core functionalities
+
+Given the Ocean Protocol job details structure as in [https://github.com/GX4FM-Base-X/pontus-x-ontology](Pontus-X Ontology), parses the passed algorithm parameters into an object to use in your algorithms.
+
+1. Parsing JSON
+1. Validation
+1. Metadata and service extraction
+
+
+### Advanced Usage (not recommended)
+
+If instead of the environment variables, we want to use another kind of mapping, can pass it as a parameter and it will work as long as it has the same key values (Can be implemented in a more generic way, but there is no need right now).
+
+```Python
+from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
+from oceanprotocol_job_details.loaders.impl.environment import Keys
+
+# Fill in with values that will be used instead of env
+custom_mapper = {
+    Keys.ROOT_FOLDER: " ... ", # Use when you don't want the algorithm to take '/' as base Path
+    Keys.ALGORITHM: " ... ",
+    Keys.DIDS: " ... ",
+    Keys.SECRET: " ... ",
+}
+
+job_details = OceanProtocolJobDetails(mapper=custom_mapper).load()
+```
+
+

{oceanprotocol_job_details-0.0.8 → oceanprotocol_job_details-0.0.10}/README.md

@@ -19,6 +19,24 @@ from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
 job_details = OceanProtocolJobDetails().load()
 ```
 
+Assumes the following directory structure:
+```
+<ROOT_FOLDER>
+└───data
+    ├───ddos
+    ├───inputs
+    └───logs
+```
+
+### Core functionalities
+
+Given the Ocean Protocol job details structure as in [https://github.com/GX4FM-Base-X/pontus-x-ontology](Pontus-X Ontology), parses the passed algorithm parameters into an object to use in your algorithms.
+
+1. Parsing JSON
+1. Validation
+1. Metadata and service extraction
+
+
 ### Advanced Usage (not recommended)
 
 If instead of the environment variables, we want to use another kind of mapping, can pass it as a parameter and it will work as long as it has the same key values (Can be implemented in a more generic way, but there is no need right now).
@@ -29,11 +47,13 @@ from oceanprotocol_job_details.loaders.impl.environment import Keys
 
 # Fill in with values that will be used instead of env
 custom_mapper = {
+    Keys.ROOT_FOLDER: " ... ", # Use when you don't want the algorithm to take '/' as base Path
     Keys.ALGORITHM: " ... ",
     Keys.DIDS: " ... ",
-    Keys.ROOT: " ... ",
     Keys.SECRET: " ... ",
 }
 
 job_details = OceanProtocolJobDetails(mapper=custom_mapper).load()
 ```
+
+

{oceanprotocol_job_details-0.0.8 → oceanprotocol_job_details-0.0.10}/oceanprotocol_job_details/dataclasses/constants.py

@@ -20,11 +20,11 @@ class _ServiceType:
     METADATA: str = "metadata"
 
 
-@dataclass(frozen=True)
+@dataclass()
 class _Paths:
     """Common paths used in the Ocean Protocol directories"""
 
-    DATA: Path = Path("data")
+    DATA: Path = Path("/data")
 
     INPUTS: Path = DATA / "inputs"
     DDOS: Path = DATA / "ddos"

{oceanprotocol_job_details-0.0.8 → oceanprotocol_job_details-0.0.10}/oceanprotocol_job_details/dataclasses/job_details.py

@@ -35,9 +35,6 @@ class Algorithm:
 class JobDetails:
     """Details of the current job, such as the used inputs and algorithm"""
 
-    root: Path
-    """The root folder of the Ocean Protocol directories"""
-
     dids: Sequence[Path]
     """Identifiers for the inputs"""
 
@@ -54,13 +51,10 @@ class JobDetails:
     _parameters: InitVar[Optional[_MetadataType]] = None
 
     def __post_init__(self, _):
-        os.makedirs(self.root / Paths.LOGS, exist_ok=True)
+        os.makedirs(Paths.LOGS, exist_ok=True)
 
         logging.getLogger().addHandler(
-            logging.FileHandler(
-                self.root / Paths.LOGS / "job_details.log",
-                mode="w",
-            )
+            logging.FileHandler(Paths.LOGS / "job_details.log", mode="w")
         )
 
     @property
@@ -68,7 +62,7 @@ class JobDetails:
         """Parameters for algorithm job, read from default path"""
 
         if parameters is None:
-            parameters = self.root / Paths.ALGORITHM_CUSTOM_PARAMETERS
+            parameters = Paths.ALGORITHM_CUSTOM_PARAMETERS
 
         if self._parameters is None:
             if not parameters.exists():

oceanprotocol_job_details-0.0.10/oceanprotocol_job_details/dataclasses/ocean.py

@@ -0,0 +1,67 @@
+from dataclasses import Field
+from datetime import datetime
+from typing import Annotated, Any, List, Optional
+
+from pydantic import BaseModel, HttpUrl
+
+"""Base classes for the Ocean Protocol algorithm structure"""
+
+
+class Credential:
+    type: Annotated[str, Field(frozen=True)]
+    values: Annotated[List[str], Field(frozen=True)]
+
+
+class Credentials:
+    allow: Optional[Annotated[List[Credential], Field(frozen=True)]] = []
+    deny: Optional[Annotated[List[Credential], Field(frozen=True)]] = []
+
+
+class Metadata(BaseModel):
+    """Base class for the Metadata structure"""
+
+    description: Annotated[str, Field(frozen=True)]
+    name: Annotated[str, Field(frozen=True)]
+    type: Annotated[str, Field(frozen=True)]
+    author: Annotated[str, Field(frozen=True)]
+    license: Annotated[str, Field(frozen=True)]
+
+    algorithm: Any
+    tags: Optional[Annotated[List[str], Field(frozen=True)]] = None
+    created: Optional[Annotated[datetime, Field(frozen=True)]] = None
+    updated: Optional[Annotated[datetime, Field(frozen=True)]] = None
+    copyrightHolder: Optional[Annotated[str, Field(frozen=True)]] = None
+    links: Optional[Annotated[List[HttpUrl], Field(frozen=True)]] = None
+    contentLanguage: Optional[Annotated[str, Field(frozen=True)]] = None
+    categories: Optional[Annotated[List[str], Field(frozen=True)]] = None
+
+
+class Service(BaseModel):
+    """Base class for the Service structure"""
+
+    id: Annotated[str, Field(frozen=True)]
+    type: Annotated[str, Field(frozen=True)]
+    timeout: Annotated[int, Field(frozen=True)]
+    files: Annotated[str, Field(frozen=True)]
+    datatokenAddress: Annotated[str, Field(frozen=True)]
+    serviceEndpoint: Annotated[HttpUrl, Field(frozen=True)]
+
+    compute: Any
+    consumerParameters: Any
+    additionalInformation: Any
+    name: Optional[Annotated[str, Field(frozen=True)]] = None
+    description: Optional[Annotated[str, Field(frozen=True)]] = None
+
+
+class DDO(BaseModel):
+    """DDO structure in Ocean Protocol"""
+
+    id: Annotated[str, Field(frozen=True)]
+    context: Annotated[List[str], Field(frozen=True)]
+    version: Annotated[str, Field(frozen=True)]
+    chainId: Annotated[int, Field(frozen=True)]
+    nftAddress: Annotated[str, Field(frozen=True)]
+    metadata: Annotated[Metadata, Field(frozen=True)]
+    services: Annotated[List[Service], Field(frozen=True)]
+
+    credentials: Annotated[Optional[str], Field(frozen=True)] = None

{oceanprotocol_job_details-0.0.8 → oceanprotocol_job_details-0.0.10}/oceanprotocol_job_details/job_details.py

@@ -1,3 +1,4 @@
+from ctypes import ArgumentError
 import logging
 import os
 from typing import Any, Literal, Mapping, Optional
@@ -10,12 +11,10 @@ from oceanprotocol_job_details.loaders.loader import Loader
 logging.basicConfig(
     level=logging.INFO,
     format="%(asctime)s [%(threadName)s] [%(levelname)s]  %(message)s",
-    handlers=[
-        logging.StreamHandler(),
-    ],
+    handlers=[logging.StreamHandler()],
 )
 
-_Implementations = Literal["env"]
+_Implementations = Literal["map"]
 
 
 class OceanProtocolJobDetails(Loader[JobDetails]):
@@ -29,14 +28,33 @@ class OceanProtocolJobDetails(Loader[JobDetails]):
         *args,
         **kwargs,
     ):
-        if implementation == "map":
-            # As there are not more implementations, we can use the EnvironmentLoader directly
-            self._loader = lambda: Map(mapper=mapper, keys=keys, *args, **kwargs)
-        else:
-            raise NotImplementedError(f"Implementation {implementation} not supported")
+        match implementation.lower():
+            case "map":
+                self._loader = lambda: Map(mapper=mapper, keys=keys, *args, **kwargs)
+            case _:
+                raise ArgumentError(f"Implementation {implementation} not valid")
 
     def load(self) -> JobDetails:
         return self._loader().load()
 
 
 del _Implementations
+
+
+def _main():
+    """Main function to test functionalities"""
+
+    # Re-define logging configuration
+    logging.basicConfig(
+        level=logging.DEBUG,
+        format="%(asctime)s [%(threadName)s] [%(levelname)s]  %(message)s",
+        handlers=[logging.StreamHandler()],
+        force=True,
+    )
+
+    job_details = OceanProtocolJobDetails().load()
+    logging.info(f"Loaded job details: {job_details}")
+
+
+if __name__ == "__main__":
+    _main()

oceanprotocol_job_details-0.0.10/oceanprotocol_job_details/loaders/impl/map.py

@@ -0,0 +1,120 @@
+"""Loads the current Job Details from the environment variables, could be abstracted to a more general 'mapper loader' but won't, since right now it fits our needs"""
+
+from dataclasses import dataclass
+from logging import getLogger
+from pathlib import Path
+from typing import Mapping, Optional, Sequence, final
+
+from orjson import JSONDecodeError, loads
+
+from oceanprotocol_job_details.dataclasses.constants import DidKeys, Paths, ServiceType
+from oceanprotocol_job_details.dataclasses.job_details import Algorithm, JobDetails
+from oceanprotocol_job_details.loaders.impl.utils import do, execute_predicate
+from oceanprotocol_job_details.loaders.loader import Loader
+
+logger = getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class Keys:
+    """Environment keys passed to the algorithm"""
+
+    ROOT_FOLDER = "ROOT_FOLDER"
+    SECRET: str = "secret"
+    ALGORITHM: str = "TRANSFORMATION_DID"
+    DIDS: str = "DIDS"
+
+
+def _update_paths_from_root(root: Path):
+    """Update the default from a root folder
+
+    :param root: root folder to update the paths
+    :type root: Path
+    """
+
+    Paths.DATA = root / "data"
+    Paths.INPUTS = Paths.DATA / "inputs"
+    Paths.DDOS = Paths.DATA / "ddos"
+    Paths.OUTPUTS = Paths.DATA / "outputs"
+    Paths.LOGS = Paths.DATA / "logs"
+    Paths.ALGORITHM_CUSTOM_PARAMETERS = Paths.INPUTS / "algoCustomData.json"
+
+
+def _files_from_service(service):
+    return service[DidKeys.ATTRIBUTES][DidKeys.MAIN][DidKeys.FILES]
+
+
+@final
+class Map(Loader[JobDetails]):
+    """Loads the current Job Details from the environment variables"""
+
+    def __init__(self, mapper: Mapping[str, str], keys: Keys, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self._mapper = mapper
+        self._keys = keys
+
+        execute_predicate(
+            lambda: _update_paths_from_root(Path(self._mapper[Keys.ROOT_FOLDER])),
+            lambda: Keys.ROOT_FOLDER in self._mapper,
+        )
+
+    def load(self, *args, **kwargs) -> JobDetails:
+        return self._from_dids(self._dids())
+
+    def _from_dids(self, dids: Sequence[Path]) -> JobDetails:
+        return JobDetails(
+            dids=dids,
+            files=self._files(dids),
+            algorithm=self._algorithm(),
+            secret=self._secret(),
+        )
+
+    def _dids(self) -> Sequence[Path]:
+        return loads(self._mapper.get(self._keys.DIDS, []))
+
+    def _files(self, dids: Optional[Sequence[Path]]) -> Mapping[str, Sequence[Path]]:
+        """Iterate through the given DIDs and retrieve their respective filepaths
+
+        :param dids: dids to read the files from
+        :type dids: Optional[Sequence[Path]]
+        :raises FileNotFoundError: if the DDO file does not exist
+        :return: _description_
+        :rtype: Mapping[str, Sequence[Path]]
+        """
+
+        files: Mapping[str, Sequence[Path]] = {}
+        for did in dids:
+            # For each given DID, check if the DDO file exists and read its metadata
+
+            ddo_path = Paths.DDOS / did
+            do(lambda: ddo_path.exists(), exc=FileNotFoundError("Missing DDO file"))
+
+            with open(ddo_path, "r") as f:
+                ddo = do(lambda: loads(f.read()), JSONDecodeError)
+                if not ddo:
+                    continue
+
+                for service in do(lambda: ddo[DidKeys.SERVICE], KeyError, default=[]):
+                    if service[DidKeys.SERVICE_TYPE] != ServiceType.METADATA:
+                        continue  # Only read the metadata of the services
+
+                    files_n = do(lambda: len(_files_from_service(service)), KeyError)
+                    ddo_path = Paths.INPUTS / did
+                    files[did] = [ddo_path / str(idx) for idx in range(files_n)]
+        return files
+
+    def _algorithm(self) -> Optional[Algorithm]:
+        did = self._mapper.get(self._keys.ALGORITHM, None)
+        if not did:
+            return None
+
+        ddo = Paths.DDOS / did
+
+        return Algorithm(
+            did,
+            do(lambda: ddo.exists() and ddo, exc=FileNotFoundError("Missing DDO file")),
+        )
+
+    def _secret(self) -> Optional[str]:
+        return self._mapper.get(self._keys.SECRET, None)

oceanprotocol_job_details-0.0.10/oceanprotocol_job_details/loaders/impl/utils.py

@@ -0,0 +1,57 @@
+from logging import WARNING, getLogger
+from typing import Callable, TypeVar
+
+logger = getLogger(__name__)
+R = TypeVar("R")
+
+
+def do(
+    function: Callable[[], R],
+    exception: Exception = Exception,
+    *,
+    log_level=WARNING,
+    default: R = None,
+    exc=False,
+) -> R:
+    """Executes a function and logs the exception if it fails
+
+    :param function: function to call
+    :type function: Callable
+    :param exception: exception to catch
+    :type exception: Exception
+    :param log_level: logging level to use
+    :type log_level: int
+    :param default: default value to return if the function fails
+    :type default: R
+    :param exc: if the exception should be raised
+    :type exc: bool
+    :return: result of the function and if it was successful
+    :rtype: R
+    """
+
+    try:
+        return function()
+    except exception as e:
+        logger.log(log_level, e)
+        if exc:
+            if isinstance(exc, Exception):
+                raise exc from e
+            raise e
+        return default
+
+
+def execute_predicate(
+    function: Callable[[], R],
+    predicate: Callable[[], bool],
+) -> R | bool:
+    """Executes a function if the predicate is true"
+
+    :param function: function to call
+    :type function: Callable
+    :param predicate: predicate to check
+    :type predicate: Callable
+    :return: result of the function and if it was successful
+    :rtype: R | bool
+    """
+
+    return predicate() and function()

{oceanprotocol_job_details-0.0.8 → oceanprotocol_job_details-0.0.10}/pyproject.toml

@@ -1,31 +1,30 @@
 [project]
-license = { file = "LICENSE" }
-
 name = "oceanprotocol-job-details"
-version = "0.0.8"
+version = "0.0.10"
+description = "A Python package to get details from OceanProtocol jobs"
 authors = [
     { name = "Christian López García", email = "christian.lopez@udl.cat" },
 ]
-description = "A Python package to get details from OceanProtocol jobs"
+requires-python = ">=3.10"
 readme = "README.md"
-requires-python = ">=3.9"
+license = { file = "LICENSE" }
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",
     "License :: OSI Approved :: MIT License",
 ]
+dependencies = ["orjson>=3.10.15", "pydantic>=2.10.6", "pytest>=8.3.4,<9"]
 
 [project.urls]
 Homepage = "https://github.com/AgrospAI/oceanprotocol-job-details"
 Issues = "https://github.com/AgrospAI/oceanprotocol-job-details/issues"
 
 [build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
-[tool.poetry]
-packages = [{ include = "oceanprotocol_job_details" }]
+[tool.hatch.build.targets.sdist]
+include = ["oceanprotocol_job_details"]
 
-[tool.poetry.dependencies]
-python = ">3.9"
-pytest = "^8.3.4"
+[tool.hatch.build.targets.wheel]
+include = ["oceanprotocol_job_details"]

oceanprotocol_job_details-0.0.8/PKG-INFO

@@ -1,62 +0,0 @@
-Metadata-Version: 2.3
-Name: oceanprotocol-job-details
-Version: 0.0.8
-Summary: A Python package to get details from OceanProtocol jobs
-License: Copyright 2025 Agrospai
-         
-         Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-         
-         The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-         
-         THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-Author: Christian López García
-Author-email: christian.lopez@udl.cat
-Requires-Python: >=3.9
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Classifier: License :: OSI Approved :: MIT License
-Requires-Dist: pytest (>=8.3.4,<9.0.0)
-Project-URL: Homepage, https://github.com/AgrospAI/oceanprotocol-job-details
-Project-URL: Issues, https://github.com/AgrospAI/oceanprotocol-job-details/issues
-Description-Content-Type: text/markdown
-
-A Python package to get details from OceanProtocol jobs
-
----
-
-## Installation
-
-```
-pip install oceanprotocol-job-details
-```
-
-## Usage 
-
-As a simple library, we only need to import the main object and use it once:
-
-```Python
-from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
-
-# Using default parameters
-job_details = OceanProtocolJobDetails().load()
-```
-
-### Advanced Usage (not recommended)
-
-If instead of the environment variables, we want to use another kind of mapping, can pass it as a parameter and it will work as long as it has the same key values (Can be implemented in a more generic way, but there is no need right now).
-
-```Python
-from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
-from oceanprotocol_job_details.loaders.impl.environment import Keys
-
-# Fill in with values that will be used instead of env
-custom_mapper = {
-    Keys.ALGORITHM: " ... ",
-    Keys.DIDS: " ... ",
-    Keys.ROOT: " ... ",
-    Keys.SECRET: " ... ",
-}
-
-job_details = OceanProtocolJobDetails(mapper=custom_mapper).load()
-```
-

oceanprotocol_job_details-0.0.8/oceanprotocol_job_details/loaders/impl/map.py

@@ -1,121 +0,0 @@
-"""Loads the current Job Details from the environment variables, could be abstracted to a more general 'mapper loader' but won't, since right now it fits our needs"""
-
-from dataclasses import dataclass
-from json import JSONDecodeError, load, loads
-from logging import getLogger
-from pathlib import Path
-from typing import Mapping, Optional, Sequence, final
-
-from oceanprotocol_job_details.dataclasses.constants import DidKeys, Paths, ServiceType
-from oceanprotocol_job_details.dataclasses.job_details import Algorithm, JobDetails
-from oceanprotocol_job_details.loaders.loader import Loader
-
-logger = getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class Keys:
-    """Environment keys passed to the algorithm"""
-
-    ROOT: str = "ROOT_FOLDER"
-    SECRET: str = "secret"
-    ALGORITHM: str = "TRANSFORMATION_DID"
-    DIDS: str = "DIDS"
-
-
-@final
-class Map(Loader[JobDetails]):
-    """Loads the current Job Details from the environment variables"""
-
-    def __init__(self, mapper: Mapping[str, str], keys: Keys, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-        self._mapper = mapper
-        self._keys = keys
-
-    def load(self, *args, **kwargs) -> JobDetails:
-        root, dids = self._root(), self._dids()
-
-        return JobDetails(
-            root=root,
-            dids=dids,
-            files=self._files(root, dids),
-            algorithm=self._algorithm(root),
-            secret=self._secret(),
-        )
-
-    def _root(self) -> Path:
-        """
-        Retrieves the root of the data from the default keys, defaults to '/'
-
-        Raises:
-            FileNotFoundError: If the given root folder does not exist
-
-        Returns:
-            Path: the root folder
-        """
-
-        root = Path(self._mapper.get(self._keys.ROOT, Path("/")))
-
-        if not root.exists():
-            raise FileNotFoundError(f"Root folder {root} does not exist")
-
-        return root
-
-    def _dids(self) -> Sequence[Path]:
-        return (
-            loads(self._mapper.get(self._keys.DIDS))
-            if self._keys.DIDS in self._mapper
-            else []
-        )
-
-    def _files(
-        self,
-        root: Path,
-        dids: Optional[Sequence[Path]],
-    ) -> Mapping[str, Sequence[Path]]:
-        files: Mapping[str, Sequence[Path]] = {}
-
-        for did in dids:
-            # Retrieve DDO from disk
-            file_path = root / Paths.DDOS / did
-            if not file_path.exists():
-                raise FileNotFoundError(f"DDO file {file_path} does not exist")
-
-            with open(file_path, "r") as f:
-                try:
-                    ddo = load(f)
-                except JSONDecodeError as e:
-                    logger.warning(f"Error loading DDO file {file_path}: {e}")
-                    continue
-
-                for service in ddo[DidKeys.SERVICE]:
-                    if service[DidKeys.SERVICE_TYPE] != ServiceType.METADATA:
-                        continue
-
-                    did_path = root / Paths.INPUTS / did
-                    files[did] = [
-                        did_path / str(idx)
-                        for idx in range(
-                            len(
-                                service[DidKeys.ATTRIBUTES][DidKeys.MAIN][DidKeys.FILES]
-                            )
-                        )
-                    ]
-
-        return files
-
-    def _algorithm(self, root: Path) -> Optional[Algorithm]:
-        did = self._mapper.get(self._keys.ALGORITHM, None)
-
-        if not did:
-            return None
-
-        ddo = root / Paths.DDOS / did
-        if not ddo.exists():
-            raise FileNotFoundError(f"DDO file {ddo} does not exist")
-
-        return Algorithm(did, ddo)
-
-    def _secret(self) -> Optional[str]:
-        return self._mapper.get(self._keys.SECRET, None)