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

{oceanprotocol_job_details-0.0.8 → oceanprotocol_job_details-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oceanprotocol-job-details
-Version: 0.0.8
+Version: 0.0.9
 Summary: A Python package to get details from OceanProtocol jobs
 License: Copyright 2025 Agrospai
          
@@ -41,6 +41,15 @@ from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
 job_details = OceanProtocolJobDetails().load()
 ```
 
+Assumes the following directory structure:
+```
+<ROOT_FOLDER>
+└───data
+    ├───ddos
+    ├───inputs
+    └───logs
+```
+
 ### 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).
@@ -51,9 +60,9 @@ 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: " ... ",
 }
 

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

@@ -19,6 +19,15 @@ from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
 job_details = OceanProtocolJobDetails().load()
 ```
 
+Assumes the following directory structure:
+```
+<ROOT_FOLDER>
+└───data
+    ├───ddos
+    ├───inputs
+    └───logs
+```
+
 ### 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,9 +38,9 @@ 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: " ... ",
 }
 

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

@@ -2,7 +2,9 @@ from dataclasses import dataclass
 from pathlib import Path
 
 
-@dataclass(frozen=True)
+@dataclass(
+    frozen=True,
+)
 class _DidKeys:
     """Common keys inside the DIDs"""
 
@@ -13,18 +15,20 @@ class _DidKeys:
     FILES: str = "files"
 
 
-@dataclass(frozen=True)
+@dataclass(
+    frozen=True,
+)
 class _ServiceType:
     """Service types inside the DIDs"""
 
     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.9}/oceanprotocol_job_details/dataclasses/job_details.py

@@ -12,7 +12,9 @@ _MetadataType = Mapping[str, Any]
 logger = logging.getLogger(__name__)
 
 
-@dataclass(frozen=True)
+@dataclass(
+    frozen=True,
+)
 class Parameters:
     """Custom data for the algorithm, such as the algorithm's parameters"""
 
@@ -20,7 +22,9 @@ class Parameters:
     """The parameters used by the algorithm"""
 
 
-@dataclass(frozen=True)
+@dataclass(
+    frozen=True,
+)
 class Algorithm:
     """Details of the algorithm used to process the data"""
 
@@ -35,9 +39,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"""
 
@@ -53,22 +54,28 @@ class JobDetails:
     # Cache parameters, should not be included as _fields_ of the class
     _parameters: InitVar[Optional[_MetadataType]] = None
 
-    def __post_init__(self, _):
-        os.makedirs(self.root / Paths.LOGS, exist_ok=True)
+    def __post_init__(
+        self,
+        _,
+    ):
+        os.makedirs(Paths.LOGS, exist_ok=True)
 
         logging.getLogger().addHandler(
             logging.FileHandler(
-                self.root / Paths.LOGS / "job_details.log",
+                Paths.LOGS / "job_details.log",
                 mode="w",
             )
         )
 
     @property
-    def parameters(self, parameters: Optional[Path] = None) -> _MetadataType:
+    def parameters(
+        self,
+        parameters: Optional[Path] = None,
+    ) -> _MetadataType:
         """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.8 → oceanprotocol_job_details-0.0.9}/oceanprotocol_job_details/job_details.py

@@ -18,7 +18,9 @@ logging.basicConfig(
 _Implementations = Literal["env"]
 
 
-class OceanProtocolJobDetails(Loader[JobDetails]):
+class OceanProtocolJobDetails(
+    Loader[JobDetails],
+):
     """Decorator that loads the JobDetails from the given implementation"""
 
     def __init__(
@@ -31,11 +33,18 @@ class OceanProtocolJobDetails(Loader[JobDetails]):
     ):
         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)
+            self._loader = lambda: Map(
+                mapper=mapper,
+                keys=keys,
+                *args,
+                **kwargs,
+            )
         else:
             raise NotImplementedError(f"Implementation {implementation} not supported")
 
-    def load(self) -> JobDetails:
+    def load(
+        self,
+    ) -> JobDetails:
         return self._loader().load()
 
 

{oceanprotocol_job_details-0.0.8 → oceanprotocol_job_details-0.0.9}/oceanprotocol_job_details/loaders/impl/map.py

@@ -1,6 +1,6 @@
 """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 dataclasses import dataclass, asdict
 from json import JSONDecodeError, load, loads
 from logging import getLogger
 from pathlib import Path
@@ -13,56 +13,66 @@ from oceanprotocol_job_details.loaders.loader import Loader
 logger = getLogger(__name__)
 
 
-@dataclass(frozen=True)
+@dataclass(
+    frozen=True,
+)
 class Keys:
     """Environment keys passed to the algorithm"""
 
-    ROOT: str = "ROOT_FOLDER"
+    ROOT_FOLDER = "ROOT_FOLDER"
     SECRET: str = "secret"
     ALGORITHM: str = "TRANSFORMATION_DID"
     DIDS: str = "DIDS"
 
 
 @final
-class Map(Loader[JobDetails]):
+class Map(
+    Loader[JobDetails],
+):
     """Loads the current Job Details from the environment variables"""
 
-    def __init__(self, mapper: Mapping[str, str], keys: Keys, *args, **kwargs):
+    def __init__(
+        self,
+        mapper: Mapping[str, str],
+        keys: Keys,
+        *args,
+        **kwargs,
+    ) -> None:
         super().__init__(*args, **kwargs)
 
         self._mapper = mapper
         self._keys = keys
 
-    def load(self, *args, **kwargs) -> JobDetails:
-        root, dids = self._root(), self._dids()
+        # Update the default Paths if the user has passed a root folder
+        if Keys.ROOT_FOLDER in self._mapper:
+            root = self._mapper[Keys.ROOT_FOLDER]
+
+            # Update the rest of paths
+            Paths.DATA = Path(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 load(
+        self,
+        *args,
+        **kwargs,
+    ) -> JobDetails:
+        dids = self._dids()
 
         return JobDetails(
-            root=root,
             dids=dids,
-            files=self._files(root, dids),
-            algorithm=self._algorithm(root),
+            files=self._files(dids),
+            algorithm=self._algorithm(),
             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]:
+    def _dids(
+        self,
+    ) -> Sequence[Path]:
         return (
             loads(self._mapper.get(self._keys.DIDS))
             if self._keys.DIDS in self._mapper
@@ -71,14 +81,13 @@ class Map(Loader[JobDetails]):
 
     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
+            file_path = Paths.DDOS / did
             if not file_path.exists():
                 raise FileNotFoundError(f"DDO file {file_path} does not exist")
 
@@ -93,7 +102,7 @@ class Map(Loader[JobDetails]):
                     if service[DidKeys.SERVICE_TYPE] != ServiceType.METADATA:
                         continue
 
-                    did_path = root / Paths.INPUTS / did
+                    did_path = Paths.INPUTS / did
                     files[did] = [
                         did_path / str(idx)
                         for idx in range(
@@ -105,17 +114,21 @@ class Map(Loader[JobDetails]):
 
         return files
 
-    def _algorithm(self, root: Path) -> Optional[Algorithm]:
+    def _algorithm(
+        self,
+    ) -> Optional[Algorithm]:
         did = self._mapper.get(self._keys.ALGORITHM, None)
 
         if not did:
             return None
 
-        ddo = root / Paths.DDOS / did
+        ddo = 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]:
+    def _secret(
+        self,
+    ) -> Optional[str]:
         return self._mapper.get(self._keys.SECRET, None)

{oceanprotocol_job_details-0.0.8 → oceanprotocol_job_details-0.0.9}/oceanprotocol_job_details/loaders/loader.py

@@ -5,9 +5,16 @@ from typing import Generic, TypeVar
 T = TypeVar("T")
 
 
-class Loader(ABC, Generic[T]):
+class Loader(
+    ABC,
+    Generic[T],
+):
     @abstractmethod
-    def load(self, *args, **kwargs) -> T:
+    def load(
+        self,
+        *args,
+        **kwargs,
+    ) -> T:
         """Load an instance of the given type"""
         pass
 

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

@@ -2,7 +2,7 @@
 license = { file = "LICENSE" }
 
 name = "oceanprotocol-job-details"
-version = "0.0.8"
+version = "0.0.9"
 authors = [
     { name = "Christian López García", email = "christian.lopez@udl.cat" },
 ]