oceanprotocol-job-details 0.0.2__py3-none-any.whl → 0.0.6__py3-none-any.whl

oceanprotocol_job_details/dataclasses/constants.py

@@ -25,11 +25,14 @@ class _Paths:
     """Common paths used in the Ocean Protocol directories"""
 
     DATA: Path = Path("data")
+
     INPUTS: Path = DATA / "inputs"
     DDOS: Path = DATA / "ddos"
     OUTPUTS: Path = DATA / "outputs"
     LOGS: Path = DATA / "logs"
 
+    ALGORITHM_CUSTOM_PARAMETERS: Path = INPUTS / "algoCustomData.json"
+
 
 DidKeys = _DidKeys()
 ServiceType = _ServiceType()

oceanprotocol_job_details/dataclasses/job_details.py

@@ -1,10 +1,29 @@
-from dataclasses import dataclass
+import json
+import logging
+import os
+from dataclasses import InitVar, dataclass
 from pathlib import Path
 from typing import Any, Mapping, Optional, Sequence
 
+from oceanprotocol_job_details.dataclasses.constants import Paths
+
+_MetadataType = Mapping[str, Any]
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class Parameters:
+    """Custom data for the algorithm, such as the algorithm's parameters"""
+
+    parameters: _MetadataType
+    """The parameters used by the algorithm"""
+
 
 @dataclass(frozen=True)
 class Algorithm:
+    """Details of the algorithm used to process the data"""
+
     did: str
     """The DID of the algorithm used to process the data"""
 
@@ -12,19 +31,16 @@ class Algorithm:
     """The DDO path of the algorithm used to process the data"""
 
 
-@dataclass(frozen=True)
+@dataclass
 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: Optional[Sequence[Path]]
+    dids: Sequence[Path]
     """Identifiers for the inputs"""
 
-    metadata: Mapping[str, Any]
-    """TODO: To define"""
-
     files: Mapping[str, Sequence[Path]]
     """Paths to the input files"""
 
@@ -33,3 +49,48 @@ class JobDetails:
 
     algorithm: Optional[Algorithm]
     """Details of the used algorithm"""
+
+    # 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)
+
+        logging.getLogger().addHandler(
+            logging.FileHandler(
+                self.root / Paths.LOGS / "job_details.log",
+                mode="w",
+            )
+        )
+
+    @property
+    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
+
+        if self._parameters is None:
+            if not parameters.exists():
+                logging.warning(
+                    f"Parameters file {parameters} not found, supplying empty"
+                )
+                self._parameters = {}
+            else:
+                # Load the parameters from filesystem
+                with open(parameters, "r") as f:
+                    try:
+                        self._parameters = json.load(f)
+                    except json.JSONDecodeError as e:
+                        self._parameters = {}
+                        logger.warning(
+                            f"Error loading parameters file {parameters}: {e}"
+                        )
+
+        return self._parameters
+
+
+del _MetadataType
+
+
+__all__ = ["Algorithm", "Parameters", "JobDetails"]

oceanprotocol_job_details/job_details.py

@@ -1,7 +1,19 @@
-from typing import Literal, Optional
+import logging
+import os
+from typing import Any, Literal, Mapping, Optional
+
 from oceanprotocol_job_details.dataclasses.job_details import JobDetails
+from oceanprotocol_job_details.loaders.impl.map import Keys, Map
 from oceanprotocol_job_details.loaders.loader import Loader
-from oceanprotocol_job_details.loaders.impl.environment import EnvironmentLoader
+
+# Logging setup for the module
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(threadName)-12.12s] [%(levelname)-5.5s]  %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+    ],
+)
 
 _Implementations = Literal["env"]
 
@@ -9,9 +21,19 @@ _Implementations = Literal["env"]
 class OceanProtocolJobDetails(Loader[JobDetails]):
     """Decorator that loads the JobDetails from the given implementation"""
 
-    def __init__(self, implementation: Optional[_Implementations], *args, **kwargs):
-        # As there are not more implementations, we can use the EnvironmentLoader directly
-        self._loader = lambda: EnvironmentLoader(*args, **kwargs)
+    def __init__(
+        self,
+        implementation: Optional[_Implementations] = "map",
+        mapper: Mapping[str, Any] = os.environ,
+        keys: Keys = Keys(),
+        *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")
 
     def load(self) -> JobDetails:
         return self._loader().load()

oceanprotocol_job_details/loaders/impl/map.py

@@ -0,0 +1,112 @@
+"""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:
+        root = Path(self._mapper.get(self._keys.ROOT, Path.home()))
+
+        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)

{oceanprotocol_job_details-0.0.2.dist-info → oceanprotocol_job_details-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: oceanprotocol-job-details
-Version: 0.0.2
+Version: 0.0.6
 Summary: A Python package to get details from OceanProtocol jobs
 License: Copyright 2025 Agrospai
          
@@ -39,8 +39,6 @@ from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
 
 # Using default parameters
 job_details = OceanProtocolJobDetails().load()
-
-job_details
 ```
 
 ### Advanced Usage (not recommended)
@@ -49,7 +47,7 @@ If instead of the environment variables, we want to use another kind of mapping,
 
 ```Python
 from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
-from src.oceanprotocol_job_details.loaders.impl.environment import Keys
+from oceanprotocol_job_details.loaders.impl.environment import Keys
 
 # Fill in with values that will be used instead of env
 custom_mapper = {
@@ -61,3 +59,4 @@ custom_mapper = {
 
 job_details = OceanProtocolJobDetails(mapper=custom_mapper).load()
 ```
+

oceanprotocol_job_details-0.0.6.dist-info/RECORD

@@ -0,0 +1,13 @@
+oceanprotocol_job_details/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/dataclasses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/dataclasses/constants.py,sha256=0hUnY2ccbvbRmxwgJC3GYaN7yoG6fccLqjxQWkH88Bo,846
+oceanprotocol_job_details/dataclasses/job_details.py,sha256=pnbNvCg0jg5rx8K9B8qbHPFetTGaMdXK94qP4PvGilw,2692
+oceanprotocol_job_details/job_details.py,sha256=eelJK85bnJIYQie65nubIwnQK3Do9X5E8cOZ1FPxSz8,1275
+oceanprotocol_job_details/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/loaders/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/loaders/impl/map.py,sha256=F6AxfRpPeRVdXtgS6jhZZM13EcGed0SszPPT5NVJmOo,3508
+oceanprotocol_job_details/loaders/loader.py,sha256=JwR6OSkzIQQkeeyAU-ad_F89W9WNvoRwvHQY7Q3zIXI,256
+oceanprotocol_job_details-0.0.6.dist-info/LICENSE,sha256=ni3ix7P_GxK1W3VGC4fJ3o6QoCngCEpSuTJwO4nkpbw,1055
+oceanprotocol_job_details-0.0.6.dist-info/METADATA,sha256=j82kvwEl86u2N0zOcM8KOGrJyUZnKJJWYB9qKfm6N4s,2793
+oceanprotocol_job_details-0.0.6.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+oceanprotocol_job_details-0.0.6.dist-info/RECORD,,

oceanprotocol_job_details/loaders/impl/environment.py

@@ -1,98 +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"""
-
-import os
-from collections.abc import Mapping, Sequence
-from dataclasses import dataclass
-from json import load, loads
-from pathlib import Path
-from typing import Optional, 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
-
-
-@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"
-
-
-Keys = _Keys()
-del _Keys
-
-
-@final
-class EnvironmentLoader(Loader[JobDetails]):
-    """Loads the current Job Details from the environment variables"""
-
-    def __init__(self, mapper: Mapping[str, str] = os.environ):
-        super().__init__()
-        self.mapper = mapper
-
-    def load(self, *args, **kwargs) -> JobDetails:
-        root, dids = self._root(), self._dids()
-
-        return JobDetails(
-            root=root,
-            dids=dids,
-            metadata=self._metadata(),
-            files=self._files(root, dids),
-            algorithm=self._algorithm(root=root),
-            secret=self._secret(),
-        )
-
-    def _root(self) -> Path:
-        return Path(self.mapper.get(Keys.ROOT, ""))
-
-    def _dids(self) -> Sequence[str]:
-        return loads(self.mapper.get(Keys.DIDS)) if 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 = root / Paths.DDOS / did
-            with open(file, "r") as f:
-                ddo = load(f)
-                for service in ddo[DidKeys.SERVICE]:
-                    if service[DidKeys.SERVICE_TYPE] == ServiceType.METADATA:
-                        base_path = root / Paths.INPUTS / did
-                        files[did] = [
-                            base_path / str(idx)
-                            for idx in range(
-                                len(
-                                    service[DidKeys.ATTRIBUTES][DidKeys.MAIN][
-                                        DidKeys.FILES
-                                    ]
-                                )
-                            )
-                        ]
-        return files
-
-    def _metadata(self) -> Mapping[str, str]:
-        return {}
-
-    def _algorithm(self, root: Path) -> Algorithm:
-        did = self.mapper.get(Keys.ALGORITHM, None)
-        if not did:
-            return None
-        return Algorithm(
-            did=did,
-            ddo=root / Paths.DDOS / did,
-        )
-
-    def _secret(self) -> str:
-        return self.mapper.get(Keys.SECRET, "")

oceanprotocol_job_details-0.0.2.dist-info/RECORD

@@ -1,27 +0,0 @@
-oceanprotocol_job_details/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oceanprotocol_job_details/dataclasses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oceanprotocol_job_details/dataclasses/__pycache__/__init__.cpython-313.pyc,sha256=0ONMfxi9YdNbrlvd7HHyKh2D2cclkF8_sfHxnk4QPT4,210
-oceanprotocol_job_details/dataclasses/__pycache__/__init__.cpython-39.pyc,sha256=MkCv5cAjpecyHxAMz5DHQAXrEfnkndNFVNGLB20iBDA,210
-oceanprotocol_job_details/dataclasses/__pycache__/constants.cpython-313.pyc,sha256=_7cahtV77VBhIQRsHzVXEkdJy-hZcJfbx50EAvwhrB8,1886
-oceanprotocol_job_details/dataclasses/__pycache__/constants.cpython-39.pyc,sha256=FGoRRGmALOKQnWO34lRxSudHkMPhYo2_XKZDeS0PwIA,1424
-oceanprotocol_job_details/dataclasses/__pycache__/job_details.cpython-313.pyc,sha256=kUxopSviCQSMPQCP5YcApB9TXUwR6XN9BI9m3rE-UKo,1369
-oceanprotocol_job_details/dataclasses/__pycache__/job_details.cpython-39.pyc,sha256=_uENugVUrWWBcjqeXKKCeT9uXz8Yd7Qg6ivag2DL87M,1038
-oceanprotocol_job_details/dataclasses/constants.py,sha256=CWkWtBgKjI8xyHPKIwJ2lStpyCTDnfnWXvcXlIFYWig,773
-oceanprotocol_job_details/dataclasses/job_details.py,sha256=7y8LoiPmAPsS71HRzm6pWbB7TwV9qIwe1Cd2Dgd4liE,860
-oceanprotocol_job_details/job_details.py,sha256=9DHS2ffOC26q-TxB9M4EUVTdwbF5jozJ9V5MljXNEM0,753
-oceanprotocol_job_details/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oceanprotocol_job_details/loaders/__pycache__/__init__.cpython-313.pyc,sha256=caqlfFNy8aRS-NJB1cTGZcxYpTtEN-jo3ko3URP0xnA,206
-oceanprotocol_job_details/loaders/__pycache__/__init__.cpython-39.pyc,sha256=8FYNSbVtqAB4scwvaAMl93XuXNHn3I1j_60CdM-wKrY,206
-oceanprotocol_job_details/loaders/__pycache__/loader.cpython-313.pyc,sha256=vHfalXDEN178-qFNfAqPhkFTSB8JhlBG_lRcpPbddUU,827
-oceanprotocol_job_details/loaders/__pycache__/loader.cpython-39.pyc,sha256=hKNDCAWHospvkKWDlkknPc6MH4tkzTbx9-vpYhX83-s,689
-oceanprotocol_job_details/loaders/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oceanprotocol_job_details/loaders/impl/__pycache__/__init__.cpython-313.pyc,sha256=SfhHqoTLJUeOLvPm9_x4niYNVumJaP4L4ilj8GNLbR0,211
-oceanprotocol_job_details/loaders/impl/__pycache__/__init__.cpython-39.pyc,sha256=RljrmsqcD5Ai1gkv0fjihE7GgTJfvugoIqyvnUBQ8r4,211
-oceanprotocol_job_details/loaders/impl/__pycache__/environment.cpython-313.pyc,sha256=hWSoqiSjFPAPuPZTiagjcHQpKDvHJU0feETedMVXenM,5628
-oceanprotocol_job_details/loaders/impl/__pycache__/environment.cpython-39.pyc,sha256=wDccIcI5AB2uBrKifVKI_MLa-bu1RDIYqICpxbMckSU,3808
-oceanprotocol_job_details/loaders/impl/environment.py,sha256=YrJwDsmHzYqd6RgNy-BwtrbdioO_1geUmigGkqbztM8,3029
-oceanprotocol_job_details/loaders/loader.py,sha256=JwR6OSkzIQQkeeyAU-ad_F89W9WNvoRwvHQY7Q3zIXI,256
-oceanprotocol_job_details-0.0.2.dist-info/LICENSE,sha256=ni3ix7P_GxK1W3VGC4fJ3o6QoCngCEpSuTJwO4nkpbw,1055
-oceanprotocol_job_details-0.0.2.dist-info/METADATA,sha256=abdDKU9LJIVynDY9ILeGlFMLlOrJyinllxfdMLQwjSA,2809
-oceanprotocol_job_details-0.0.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-oceanprotocol_job_details-0.0.2.dist-info/RECORD,,