oceanprotocol-job-details 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

oceanprotocol_job_details/dataclasses/constants.py

@@ -2,9 +2,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 
-@dataclass(
-    frozen=True,
-)
+@dataclass(frozen=True)
 class _DidKeys:
     """Common keys inside the DIDs"""
 
@@ -15,9 +13,7 @@ class _DidKeys:
     FILES: str = "files"
 
 
-@dataclass(
-    frozen=True,
-)
+@dataclass(frozen=True)
 class _ServiceType:
     """Service types inside the DIDs"""
 

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]
@@ -12,9 +13,7 @@ _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"""
 
@@ -22,9 +21,7 @@ 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"""
 
@@ -54,24 +51,8 @@ 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:
+    def parameters(self, parameters: Optional[Path] = None) -> _MetadataType:
         """Parameters for algorithm job, read from default path"""
 
         if parameters is None:
@@ -79,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/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/job_details.py

@@ -1,3 +1,4 @@
+from ctypes import ArgumentError
 import logging
 import os
 from typing import Any, Literal, Mapping, Optional
@@ -10,17 +11,13 @@ 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],
-):
+class OceanProtocolJobDetails(Loader[JobDetails]):
     """Decorator that loads the JobDetails from the given implementation"""
 
     def __init__(
@@ -31,21 +28,33 @@ class OceanProtocolJobDetails(
         *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:
+        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/loaders/impl/map.py

@@ -1,21 +1,21 @@
 """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, asdict
-from json import JSONDecodeError, load, loads
+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,
-)
+@dataclass(frozen=True)
 class Keys:
     """Environment keys passed to the algorithm"""
 
@@ -25,44 +25,42 @@ class Keys:
     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],
-):
+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)
-
+    def __init__(self, mapper: Mapping[str, str], keys: Keys, *args, **kwargs) -> None:
         self._mapper = mapper
         self._keys = keys
 
-        # 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"
-
+        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:
-        dids = self._dids()
+    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),
@@ -70,65 +68,51 @@ class Map(
             secret=self._secret(),
         )
 
-    def _dids(
-        self,
-    ) -> Sequence[Path]:
-        return (
-            loads(self._mapper.get(self._keys.DIDS))
-            if self._keys.DIDS in self._mapper
-            else []
-        )
+    def _dids(self) -> Sequence[Path]:
+        return loads(self._mapper.get(self._keys.DIDS, []))
 
-    def _files(
-        self,
-        dids: Optional[Sequence[Path]],
-    ) -> Mapping[str, Sequence[Path]]:
-        files: Mapping[str, Sequence[Path]] = {}
+    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:
-            # Retrieve DDO from disk
-            file_path = 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}")
+            # 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 ddo[DidKeys.SERVICE]:
+                for service in do(lambda: ddo[DidKeys.SERVICE], KeyError, default=[]):
                     if service[DidKeys.SERVICE_TYPE] != ServiceType.METADATA:
-                        continue
-
-                    did_path = Paths.INPUTS / did
-                    files[did] = [
-                        did_path / str(idx)
-                        for idx in range(
-                            len(
-                                service[DidKeys.ATTRIBUTES][DidKeys.MAIN][DidKeys.FILES]
-                            )
-                        )
-                    ]
+                        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]:
+    def _algorithm(self) -> Optional[Algorithm]:
         did = self._mapper.get(self._keys.ALGORITHM, None)
-
         if not did:
             return None
 
         ddo = Paths.DDOS / did
-        if not ddo.exists():
-            raise FileNotFoundError(f"DDO file {ddo} does not exist")
 
-        return Algorithm(did, ddo)
+        return Algorithm(
+            did,
+            do(lambda: ddo.exists() and ddo, exc=FileNotFoundError("Missing DDO file")),
+        )
 
-    def _secret(
-        self,
-    ) -> Optional[str]:
+    def _secret(self) -> Optional[str]:
         return self._mapper.get(self._keys.SECRET, None)

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/loaders/loader.py

@@ -5,16 +5,9 @@ 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.9.dist-info → oceanprotocol_job_details-0.0.11.dist-info}/METADATA

@@ -1,23 +1,25 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: oceanprotocol-job-details
-Version: 0.0.9
+Version: 0.0.11
 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
+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
@@ -50,6 +52,15 @@ Assumes the following directory structure:
     └───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).
@@ -69,3 +80,4 @@ custom_mapper = {
 job_details = OceanProtocolJobDetails(mapper=custom_mapper).load()
 ```
 
+

oceanprotocol_job_details-0.0.11.dist-info/RECORD

@@ -0,0 +1,15 @@
+oceanprotocol_job_details/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/job_details.py,sha256=dlQABSV8TQf66vaeFImyw7c4Nms417pRKiDR9d4qDhY,1668
+oceanprotocol_job_details/dataclasses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/dataclasses/constants.py,sha256=EHUhbaFpixtK5Kq2V92gbWg-jxYR-tO6ie4Ntb_FPGQ,836
+oceanprotocol_job_details/dataclasses/job_details.py,sha256=jho4PQLyqh1iB6e5wlM9ATSZreqAo7J9hOeFdETSHgo,2311
+oceanprotocol_job_details/dataclasses/ocean.py,sha256=u4Mc5cHPnJz9oc1a43kkWfwEqRgsFsb-Y3UP2eBpoN4,2480
+oceanprotocol_job_details/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/loaders/loader.py,sha256=JwR6OSkzIQQkeeyAU-ad_F89W9WNvoRwvHQY7Q3zIXI,256
+oceanprotocol_job_details/loaders/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/loaders/impl/map.py,sha256=5DF5HilWhmF_lq4j3VdAbyCbGRPGQPkn_-l7K-TOVmM,4090
+oceanprotocol_job_details/loaders/impl/utils.py,sha256=rxoG8PrXRSKKDYPZh-wkWOXzMfdWXrkZs0f04OfDCIs,1446
+oceanprotocol_job_details-0.0.11.dist-info/METADATA,sha256=nuTtra3JG0LP5wcG5PkdC5fdYGirZbQhDE6TRAdajlw,3382
+oceanprotocol_job_details-0.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+oceanprotocol_job_details-0.0.11.dist-info/licenses/LICENSE,sha256=ni3ix7P_GxK1W3VGC4fJ3o6QoCngCEpSuTJwO4nkpbw,1055
+oceanprotocol_job_details-0.0.11.dist-info/RECORD,,

{oceanprotocol_job_details-0.0.9.dist-info → oceanprotocol_job_details-0.0.11.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

oceanprotocol_job_details-0.0.9.dist-info/RECORD

@@ -1,13 +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/constants.py,sha256=4bUtp5JA4Sp22CW7L3oLrGG2SmYpAEOCXd59k5rKFyg,850
-oceanprotocol_job_details/dataclasses/job_details.py,sha256=iH52jd6XCplP2Z40qDO0lbFCTm7suVNPyLVgYkeOtQ0,2640
-oceanprotocol_job_details/job_details.py,sha256=E5z_4ZlvSJSi1IJslSTi3X36UI_FHeaZkOyfCxxeJXw,1366
-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=c3GNrLk14Hc3vu8OJFwcUb_23ZVzbkG3iaJ4rVi4sZs,3861
-oceanprotocol_job_details/loaders/loader.py,sha256=ZedS7sA3K3uAIvc-yLRjgHIAen6_XyHO6sXhqm55kYo,298
-oceanprotocol_job_details-0.0.9.dist-info/LICENSE,sha256=ni3ix7P_GxK1W3VGC4fJ3o6QoCngCEpSuTJwO4nkpbw,1055
-oceanprotocol_job_details-0.0.9.dist-info/METADATA,sha256=Zd2nclEtjLf62kw2GTNNqI9Z0FDsQSfESePhoRaIQ0E,3013
-oceanprotocol_job_details-0.0.9.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-oceanprotocol_job_details-0.0.9.dist-info/RECORD,,