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

{oceanprotocol_job_details-0.0.10 → oceanprotocol_job_details-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oceanprotocol-job-details
-Version: 0.0.10
+Version: 0.0.12
 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

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

@@ -6,7 +6,7 @@ from pathlib import Path
 class _DidKeys:
     """Common keys inside the DIDs"""
 
-    SERVICE: str = "service"
+    SERVICES: str = "services"
     SERVICE_TYPE: str = "type"
     ATTRIBUTES: str = "attributes"
     MAIN: str = "main"

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

@@ -1,10 +1,11 @@
-import json
 import logging
 import os
 from dataclasses import InitVar, dataclass
 from pathlib import Path
 from typing import Any, Mapping, Optional, Sequence
 
+from orjson import JSONDecodeError, loads
+
 from oceanprotocol_job_details.dataclasses.constants import Paths
 
 _MetadataType = Mapping[str, Any]
@@ -50,13 +51,6 @@ class JobDetails:
     # Cache parameters, should not be included as _fields_ of the class
     _parameters: InitVar[Optional[_MetadataType]] = None
 
-    def __post_init__(self, _):
-        os.makedirs(Paths.LOGS, exist_ok=True)
-
-        logging.getLogger().addHandler(
-            logging.FileHandler(Paths.LOGS / "job_details.log", mode="w")
-        )
-
     @property
     def parameters(self, parameters: Optional[Path] = None) -> _MetadataType:
         """Parameters for algorithm job, read from default path"""
@@ -66,16 +60,14 @@ class JobDetails:
 
         if self._parameters is None:
             if not parameters.exists():
-                logging.warning(
-                    f"Parameters file {parameters} not found, supplying empty"
-                )
+                logging.warning(f"Missing parameters file: {parameters} not found")
                 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 = loads(f.read())
+                    except JSONDecodeError as e:
                         self._parameters = {}
                         logger.warning(
                             f"Error loading parameters file {parameters}: {e}"

{oceanprotocol_job_details-0.0.10 → oceanprotocol_job_details-0.0.12}/oceanprotocol_job_details/dataclasses/ocean.py

@@ -1,67 +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
+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.10 → oceanprotocol_job_details-0.0.12}/oceanprotocol_job_details/job_details.py

@@ -1,4 +1,3 @@
-from ctypes import ArgumentError
 import logging
 import os
 from typing import Any, Literal, Mapping, Optional
@@ -14,7 +13,7 @@ logging.basicConfig(
     handlers=[logging.StreamHandler()],
 )
 
-_Implementations = Literal["map"]
+_Implementations = Literal["env"]
 
 
 class OceanProtocolJobDetails(Loader[JobDetails]):
@@ -28,33 +27,14 @@ class OceanProtocolJobDetails(Loader[JobDetails]):
         *args,
         **kwargs,
     ):
-        match implementation.lower():
-            case "map":
-                self._loader = lambda: Map(mapper=mapper, keys=keys, *args, **kwargs)
-            case _:
-                raise ArgumentError(f"Implementation {implementation} not valid")
+        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()
 
 
 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-0.0.12}/oceanprotocol_job_details/loaders/impl/map.py

@@ -41,7 +41,10 @@ def _update_paths_from_root(root: Path):
 
 
 def _files_from_service(service):
-    return service[DidKeys.ATTRIBUTES][DidKeys.MAIN][DidKeys.FILES]
+    files = service[DidKeys.FILES]
+    if isinstance(files, str):
+        return [files]
+    return files
 
 
 @final
@@ -49,8 +52,6 @@ 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
 
@@ -62,7 +63,7 @@ class Map(Loader[JobDetails]):
     def load(self, *args, **kwargs) -> JobDetails:
         return self._from_dids(self._dids())
 
-    def _from_dids(self, dids: Sequence[Path]) -> JobDetails:
+    def _from_dids(self, dids: Sequence[str]) -> JobDetails:
         return JobDetails(
             dids=dids,
             files=self._files(dids),
@@ -70,14 +71,14 @@ class Map(Loader[JobDetails]):
             secret=self._secret(),
         )
 
-    def _dids(self) -> Sequence[Path]:
+    def _dids(self) -> Sequence[str]:
         return loads(self._mapper.get(self._keys.DIDS, []))
 
-    def _files(self, dids: Optional[Sequence[Path]]) -> Mapping[str, Sequence[Path]]:
+    def _files(self, dids: Optional[Sequence[str]]) -> 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]]
+        :type dids: Optional[Sequence[str]]
         :raises FileNotFoundError: if the DDO file does not exist
         :return: _description_
         :rtype: Mapping[str, Sequence[Path]]
@@ -86,7 +87,6 @@ class Map(Loader[JobDetails]):
         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"))
 
@@ -95,9 +95,9 @@ class Map(Loader[JobDetails]):
                 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
+                for service in do(lambda: ddo[DidKeys.SERVICES], 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

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

@@ -1,6 +1,6 @@
 [project]
 name = "oceanprotocol-job-details"
-version = "0.0.10"
+version = "0.0.12"
 description = "A Python package to get details from OceanProtocol jobs"
 authors = [
     { name = "Christian López García", email = "christian.lopez@udl.cat" },