oceanprotocol-job-details 0.0.1__tar.gz

oceanprotocol_job_details-0.0.1/LICENSE

@@ -0,0 +1,7 @@
+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.

oceanprotocol_job_details-0.0.1/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.3
+Name: oceanprotocol-job-details
+Version: 0.0.1
+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
+```

oceanprotocol_job_details-0.0.1/README.md

@@ -0,0 +1,9 @@
+A Python package to get details from OceanProtocol jobs
+
+---
+
+## Installation
+
+```
+pip install oceanprotocol-job-details
+```

oceanprotocol_job_details-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+license = { file = "LICENSE" }
+
+name = "oceanprotocol-job-details"
+version = "0.0.1"
+authors = [
+    { name = "Christian López García", email = "christian.lopez@udl.cat" },
+]
+description = "A Python package to get details from OceanProtocol jobs"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "License :: OSI Approved :: MIT License",
+]
+
+[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"
+
+[tool.poetry]
+packages = [{ include = "src/oceanprotocol_job_details" }]
+
+[tool.poetry.dependencies]
+python = ">3.9"
+pytest = "^8.3.4"

oceanprotocol_job_details-0.0.1/src/oceanprotocol_job_details/dataclasses/constants.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class _DidKeys:
+    """Common keys inside the DIDs"""
+
+    SERVICE: str = "service"
+    SERVICE_TYPE: str = "type"
+    ATTRIBUTES: str = "attributes"
+    MAIN: str = "main"
+    FILES: str = "files"
+
+
+@dataclass(frozen=True)
+class _ServiceType:
+    """Service types inside the DIDs"""
+
+    METADATA: str = "metadata"
+
+
+@dataclass(frozen=True)
+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"
+
+
+DidKeys = _DidKeys()
+ServiceType = _ServiceType()
+Paths = _Paths()
+
+del _DidKeys, _ServiceType, _Paths

oceanprotocol_job_details-0.0.1/src/oceanprotocol_job_details/dataclasses/job_details.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping, Optional, Sequence
+
+
+@dataclass(frozen=True)
+class Algorithm:
+    did: str
+    """The DID of the algorithm used to process the data"""
+
+    ddo: Path
+    """The DDO path of the algorithm used to process the data"""
+
+
+@dataclass(frozen=True)
+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]]
+    """Identifiers for the inputs"""
+
+    metadata: Mapping[str, Any]
+    """TODO: To define"""
+
+    files: Mapping[str, Sequence[Path]]
+    """Paths to the input files"""
+
+    secret: Optional[str]
+    """The secret used to process the data"""
+
+    algorithm: Optional[Algorithm]
+    """Details of the used algorithm"""

oceanprotocol_job_details-0.0.1/src/oceanprotocol_job_details/job_details.py

@@ -0,0 +1,20 @@
+from typing import Literal, Optional
+from src.oceanprotocol_job_details.dataclasses.job_details import JobDetails
+from src.oceanprotocol_job_details.loaders.loader import Loader
+from src.oceanprotocol_job_details.loaders.impl.environment import EnvironmentLoader
+
+_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 load(self) -> JobDetails:
+        return self._loader().load()
+
+
+del _Implementations

oceanprotocol_job_details-0.0.1/src/oceanprotocol_job_details/loaders/impl/environment.py

@@ -0,0 +1,98 @@
+"""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 src.oceanprotocol_job_details.dataclasses.constants import (
+    DidKeys,
+    Paths,
+    ServiceType,
+)
+from src.oceanprotocol_job_details.dataclasses.job_details import Algorithm, JobDetails
+from src.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.1/src/oceanprotocol_job_details/loaders/loader.py

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