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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oceanprotocol-job-details
-Version: 0.0.12
+Version: 0.1.1
 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
@@ -17,9 +17,7 @@ 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
+Requires-Dist: dataclasses-json>=0.6.7
 Description-Content-Type: text/markdown
 
 A Python package to get details from OceanProtocol jobs
@@ -39,8 +37,30 @@ As a simple library, we only need to import the main object and use it once:
 ```Python
 from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
 
-# Using default parameters
-job_details = OceanProtocolJobDetails().load()
+# Having no algorithm input parameters
+job_details = OceanProtocolJobDetails().load()  # type: ignore
+
+```
+
+If our algorithm has custom input parameters and we want to load them into our algorithm, we can do it as follows:
+
+```Python
+
+from dataclasses import dataclass
+from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
+from oceanprotocol_job_details.ocean import JobDetails
+
+@dataclass
+class Input:
+    name: str
+    age: int
+
+job_details: JobDetails[Input] = OceanProtocolJobDetails(Input).load()
+
+# Usage (is type hinted)
+job_details.input_parameters.name
+job_details.input_parameters.age
+
 ```
 
 Assumes the following directory structure:
@@ -48,6 +68,7 @@ Assumes the following directory structure:
 <ROOT_FOLDER>
 └───data
     ├───ddos
+    ├───transformation
     ├───inputs
     └───logs
 ```
@@ -59,25 +80,3 @@ Given the Ocean Protocol job details structure as in [https://github.com/GX4FM-B
 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).
-
-```Python
-from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
-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.SECRET: " ... ",
-}
-
-job_details = OceanProtocolJobDetails(mapper=custom_mapper).load()
-```
-
-

{oceanprotocol_job_details-0.0.12 → oceanprotocol_job_details-0.1.1}/README.md

@@ -15,8 +15,30 @@ As a simple library, we only need to import the main object and use it once:
 ```Python
 from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
 
-# Using default parameters
-job_details = OceanProtocolJobDetails().load()
+# Having no algorithm input parameters
+job_details = OceanProtocolJobDetails().load()  # type: ignore
+
+```
+
+If our algorithm has custom input parameters and we want to load them into our algorithm, we can do it as follows:
+
+```Python
+
+from dataclasses import dataclass
+from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
+from oceanprotocol_job_details.ocean import JobDetails
+
+@dataclass
+class Input:
+    name: str
+    age: int
+
+job_details: JobDetails[Input] = OceanProtocolJobDetails(Input).load()
+
+# Usage (is type hinted)
+job_details.input_parameters.name
+job_details.input_parameters.age
+
 ```
 
 Assumes the following directory structure:
@@ -24,6 +46,7 @@ Assumes the following directory structure:
 <ROOT_FOLDER>
 └───data
     ├───ddos
+    ├───transformation
     ├───inputs
     └───logs
 ```
@@ -35,25 +58,3 @@ Given the Ocean Protocol job details structure as in [https://github.com/GX4FM-B
 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).
-
-```Python
-from oceanprotocol_job_details.job_details import OceanProtocolJobDetails
-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.SECRET: " ... ",
-}
-
-job_details = OceanProtocolJobDetails(mapper=custom_mapper).load()
-```
-
-

oceanprotocol_job_details-0.1.1/oceanprotocol_job_details/config.py

@@ -0,0 +1,53 @@
+from dataclasses import dataclass, fields
+from logging import getLogger
+from pathlib import Path
+
+logger = getLogger(__name__)
+
+
+@dataclass
+class Config:
+    """Configuration class for the Ocean Protocol Job Details"""
+
+    path_data: str = "/data"
+    """The path to the data directory"""
+
+    path_inputs: str = path_data + "/inputs"
+    """The path to the inputs directory"""
+
+    path_ddos: str = path_data + "/ddos"
+    """The path to the DDOs directory"""
+
+    path_outputs: str = path_data + "/outputs"
+    """The path to the outputs directory"""
+
+    path_logs: str = path_data + "/logs"
+    """The path to the logs directory"""
+
+    path_algorithm_custom_parameters: str = path_inputs + "/algoCustomData.json"
+    """The path to the algorithm's custom parameters file"""
+
+
+config = Config()
+
+
+def update_config_from(base: Path) -> None:
+    """Updates the configuration to use the new base path, ensures that the base path exists.
+
+    Args:
+        base (Path): The new base path to use.
+    """
+
+    logger.info(f"Updating config to use base path: {base}")
+
+    base.mkdir(parents=True, exist_ok=True)
+
+    for field in fields(config):
+        default_value = field.default
+        if default_value is None or not isinstance(default_value, Path):
+            raise ValueError(f"Field {field.name} has no default value")
+
+        object.__setattr__(config, field.name, str(base / default_value))
+
+
+__all__ = ["config"]

oceanprotocol_job_details-0.1.1/oceanprotocol_job_details/job_details.py

@@ -0,0 +1,47 @@
+import logging
+from dataclasses import dataclass
+from typing import Generic, Type, TypeVar
+
+from dataclasses_json import dataclass_json
+
+from oceanprotocol_job_details.loaders.impl.job_details import JobDetailsLoader
+from oceanprotocol_job_details.loaders.loader import Loader
+from oceanprotocol_job_details.ocean import JobDetails
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(threadName)s] [%(levelname)s]  %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+
+@dataclass_json
+@dataclass
+class _EmptyJobDetails: ...
+
+
+T = TypeVar("T")
+
+
+class OceanProtocolJobDetails(Generic[T]):
+    """The JobDetails class is a dataclass that holds the details of the current job.
+
+    Loading it will check the following:
+    1. That the needed environment variables are set
+    1. That the ocean protocol contains the needed data based on the passed environment variables
+
+    Those needed environment variables are:
+    - DIDS: The DIDs of the inputs
+    - TRANSFORMATION_DID: The DID of the transformation algorithm
+    - SECRET (optional): A really secret secret
+
+    """
+
+    def __init__(self, _type: Type[T] | None = None) -> None:
+        if _type is None:
+            _type = _EmptyJobDetails  # type: ignore[assignment]
+        self.job_details_loader: Loader[JobDetails[T]] = JobDetailsLoader(_type)  # type: ignore[arg-type]
+
+    def load(self) -> JobDetails[T]:
+        return self.job_details_loader.load()

oceanprotocol_job_details-0.1.1/oceanprotocol_job_details/loaders/impl/ddo.py

@@ -0,0 +1,26 @@
+from dataclasses import InitVar, dataclass, field
+from pathlib import Path
+from typing import final
+
+from oceanprotocol_job_details.ocean import DDO
+
+
+@final
+@dataclass(frozen=True)
+class DDOLoader:
+    ddo_paths: InitVar[list[Path]]
+    """The files to load the DDOs from"""
+
+    _ddo_paths: list[Path] = field(init=False)
+
+    def __post_init__(self, ddo_paths: list[Path]) -> None:
+        assert ddo_paths, "Missing DDO paths"
+
+        object.__setattr__(self, "_ddo_paths", ddo_paths)
+
+    def load(self) -> list[DDO]:
+        ddos = []
+        for path in self._ddo_paths:
+            with open(path, "r") as f:
+                ddos.append(DDO.from_json(f.read()))  # type: ignore
+        return ddos

oceanprotocol_job_details-0.1.1/oceanprotocol_job_details/loaders/impl/files.py

@@ -0,0 +1,71 @@
+from dataclasses import InitVar, dataclass, field
+from pathlib import Path
+from typing import Iterator, Sequence, final
+
+import json
+
+from oceanprotocol_job_details.config import config
+
+
+@dataclass(frozen=True)
+class DIDPaths:
+    did: str
+    ddo: Path
+    input_files: Sequence[Path]
+
+    def __post_init__(self) -> None:
+        assert self.ddo.exists(), f"DDO {self.ddo} does not exist"
+        for input_file in self.input_files:
+            assert input_file.exists(), f"File {input_file} does not exist"
+
+    def __len__(self) -> int:
+        return len(self.input_files)
+
+
+@dataclass(frozen=True)
+class Files:
+    files: Sequence[DIDPaths]
+
+    def __iter__(self) -> Iterator[DIDPaths]:
+        return iter(self.files)
+
+    def __len__(self) -> int:
+        return len(self.files)
+
+
+@final
+@dataclass(frozen=True)
+class FilesLoader:
+    dids: InitVar[str | None]
+    """Input DIDs"""
+
+    transformation_did: InitVar[str | None]
+    """DID for the transformation algorithm"""
+
+    _dids: Sequence[str] = field(init=False)
+    _transformation_did: str = field(init=False)
+
+    def __post_init__(
+        self,
+        dids: str | None,
+        transformation_did: str | None,
+    ) -> None:
+        assert dids, "Missing DIDs"
+        assert transformation_did, "Missing transformation DID"
+
+        object.__setattr__(self, "_dids", json.loads(dids))
+        object.__setattr__(self, "_transformation_did", transformation_did)
+
+    def load(self) -> Files:
+        files: list[DIDPaths] = []
+        for did in self._dids:
+            base = Path(config.path_inputs) / did
+            files.append(
+                DIDPaths(
+                    did=did,
+                    ddo=Path(config.path_ddos) / did,
+                    input_files=list(base.iterdir()),
+                )
+            )
+
+        return Files(files)

oceanprotocol_job_details-0.1.1/oceanprotocol_job_details/loaders/impl/job_details.py

@@ -0,0 +1,25 @@
+import os
+from dataclasses import dataclass, field
+from typing import Generic, Type, TypeVar, final
+
+from oceanprotocol_job_details.loaders.impl.ddo import DDOLoader
+from oceanprotocol_job_details.loaders.impl.files import FilesLoader
+from oceanprotocol_job_details.ocean import JobDetails
+
+T = TypeVar("T")
+
+
+@final
+@dataclass(frozen=True)
+class JobDetailsLoader(Generic[T]):
+    _type: Type[T] = field(repr=False)
+
+    def load(self) -> JobDetails[T]:
+        dids = os.environ.get("DIDS")
+        transformation_did = os.environ.get("TRANSFORMATION_DID")
+        secret = os.environ.get("SECRET")
+
+        files = FilesLoader(dids, transformation_did).load()
+        ddos = DDOLoader([f.ddo for f in files]).load()
+
+        return JobDetails(files=files, secret=secret, ddos=ddos, _type=self._type)

oceanprotocol_job_details-0.1.1/oceanprotocol_job_details/loaders/loader.py

@@ -0,0 +1,13 @@
+from typing import Protocol, TypeVar
+
+T = TypeVar("T", covariant=True)
+
+
+class Loader(Protocol[T]):
+
+    def load(self) -> T:
+        """Load an instance of the given type"""
+        ...
+
+
+del T

oceanprotocol_job_details-0.1.1/oceanprotocol_job_details/ocean.py

@@ -0,0 +1,183 @@
+from dataclasses import dataclass, field
+from functools import cached_property
+from typing import Any, Generic, Optional, Type, TypeVar, final
+
+from dataclasses_json import config as dc_config
+from dataclasses_json import dataclass_json
+
+from oceanprotocol_job_details.config import config
+from oceanprotocol_job_details.loaders.impl.files import Files
+
+T = TypeVar("T")
+
+
+@dataclass_json
+@dataclass
+class Credential:
+    type: str
+    values: list[str]
+
+
+@dataclass_json
+@dataclass
+class Credentials:
+    allow: list[Credential]
+    deny: list[Credential]
+
+
+@dataclass_json
+@dataclass
+class Container:
+    image: str
+    tag: str
+    entrypoint: str
+
+
+@dataclass_json
+@dataclass
+class Algorithm:  # type: ignore
+    container: Container
+    language: str
+    version: str
+    consumerParameters: Any  # type: ignore
+
+
+@dataclass_json
+@dataclass
+class Metadata:
+    description: str
+    name: str
+    type: str
+    author: str
+    license: str
+    algorithm: Optional[Algorithm] = None
+    tags: Optional[list[str]] = None
+    created: Optional[str] = None
+    updated: Optional[str] = None
+    copyrightHolder: Optional[str] = None
+    links: Optional[list[str]] = None
+    contentLanguage: Optional[str] = None
+    categories: Optional[list[str]] = None
+
+
+@dataclass_json
+@dataclass
+class ConsumerParameters:
+    name: str
+    type: str
+    label: str
+    required: bool
+    description: str
+    default: str
+    option: Optional[list[str]] = None
+
+
+@dataclass_json
+@dataclass
+class Service:
+    id: str
+    type: str
+    timeout: int
+    files: str
+    datatokenAddress: str
+    serviceEndpoint: str
+    additionalInformation: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+
+@dataclass_json
+@dataclass
+class Event:
+    tx: str
+    block: int
+    from_: str = field(metadata=dc_config(field_name="from"))
+    contract: str
+    datetime: str
+
+
+@dataclass_json
+@dataclass
+class NFT:
+    address: str
+    name: str
+    symbol: str
+    state: int
+    tokenURI: str
+    owner: str
+    created: str
+
+
+@dataclass_json
+@dataclass
+class DataToken:
+    address: str
+    name: str
+    symbol: str
+    serviceId: str
+
+
+@dataclass_json
+@dataclass
+class Price:
+    value: int
+
+
+@dataclass_json
+@dataclass
+class Stats:
+    allocated: int
+    orders: int
+    price: Price
+
+
+@dataclass_json
+@dataclass
+class Purgatory:
+    state: bool
+
+
+@dataclass_json
+@dataclass
+class DDO:
+    id: str
+    context: list[str] = field(metadata=dc_config(field_name="@context"))
+    nftAddress: str
+    chainId: int
+    version: str
+    metadata: Metadata
+    services: list[Service]
+    credentials: Credentials
+    event: Event
+    nft: NFT
+    datatokens: list[DataToken]
+    stats: Stats
+    purgatory: Purgatory
+
+
+@final
+@dataclass_json
+@dataclass(frozen=True)
+class JobDetails(Generic[T]):
+    files: Files
+    """The input filepaths"""
+
+    ddos: list[DDO]
+    """list of paths to the DDOs"""
+
+    # Store the type explicitly to avoid issues
+    _type: Type[T] = field(repr=False)
+
+    secret: str | None = None
+    """Shh it's a secret"""
+
+    def __post_init__(self) -> None:
+        if not hasattr(self._type, "__dataclass_fields__"):
+            raise TypeError(f"{self._type} is not a dataclass type")
+
+    @cached_property
+    def input_parameters(self) -> T:
+        """Read the input parameters and return them in an instance of the dataclass T"""
+
+        with open(config.path_algorithm_custom_parameters, "r") as f:
+            return dataclass_json(self._type).from_json(f.read())  # type: ignore

oceanprotocol_job_details-0.1.1/oceanprotocol_job_details/utils.py

@@ -0,0 +1,33 @@
+from logging import getLogger
+from typing import Mapping, Optional, TypeVar
+
+T = TypeVar("T")
+logger = getLogger(__name__)
+
+
+def get(
+    map: Mapping[str, T],
+    key: str,
+    default: Optional[T] = None,
+) -> T | None:
+    """Get the value of a key from a dictionary, if not found return the default value if given, otherwise raise a KeyError
+
+    :param map: original map to get the item from
+    :type map: Mapping[str, T]
+    :param key: key to get the value from
+    :type key: str
+    :param default: default value if missing, defaults to None
+    :type default: Optional[T], optional
+    :raises KeyError: if the value is missing and no default is provided
+    :return: value of the key
+    :rtype: T
+    """
+
+    if key in map.keys():
+        return map.get(key)
+
+    if default is None:
+        raise KeyError(f"Key {key} not found")
+
+    logger.info(f"Key {key} not found, returning default value {default}")
+    return default

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

@@ -1,6 +1,6 @@
 [project]
 name = "oceanprotocol-job-details"
-version = "0.0.12"
+version = "0.1.1"
 description = "A Python package to get details from OceanProtocol jobs"
 authors = [
     { name = "Christian López García", email = "christian.lopez@udl.cat" },
@@ -13,12 +13,15 @@ classifiers = [
     "Operating System :: OS Independent",
     "License :: OSI Approved :: MIT License",
 ]
-dependencies = ["orjson>=3.10.15", "pydantic>=2.10.6", "pytest>=8.3.4,<9"]
+dependencies = ["dataclasses-json>=0.6.7"]
 
 [project.urls]
 Homepage = "https://github.com/AgrospAI/oceanprotocol-job-details"
 Issues = "https://github.com/AgrospAI/oceanprotocol-job-details/issues"
 
+[tool.pytest.ini_options]
+pythonpath = "oceanprotocol_job_details"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -28,3 +31,11 @@ include = ["oceanprotocol_job_details"]
 
 [tool.hatch.build.targets.wheel]
 include = ["oceanprotocol_job_details"]
+
+[tool.mypy]
+strict = true
+warn_return_any = true
+disallow_any_explicit = true
+
+[dependency-groups]
+dev = ["mypy>=1.15.0", "pytest>=8.3.4"]

oceanprotocol_job_details-0.0.12/oceanprotocol_job_details/dataclasses/constants.py

@@ -1,41 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass(frozen=True)
-class _DidKeys:
-    """Common keys inside the DIDs"""
-
-    SERVICES: str = "services"
-    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()
-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()
-Paths = _Paths()
-
-del _DidKeys, _ServiceType, _Paths

oceanprotocol_job_details-0.0.12/oceanprotocol_job_details/dataclasses/job_details.py

@@ -1,82 +0,0 @@
-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]
-
-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"""
-
-    ddo: Path
-    """The DDO path of the algorithm used to process the data"""
-
-
-@dataclass
-class JobDetails:
-    """Details of the current job, such as the used inputs and algorithm"""
-
-    dids: Sequence[Path]
-    """Identifiers for the inputs"""
-
-    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"""
-
-    # Cache parameters, should not be included as _fields_ of the class
-    _parameters: InitVar[Optional[_MetadataType]] = None
-
-    @property
-    def parameters(self, parameters: Optional[Path] = None) -> _MetadataType:
-        """Parameters for algorithm job, read from default path"""
-
-        if parameters is None:
-            parameters = Paths.ALGORITHM_CUSTOM_PARAMETERS
-
-        if self._parameters is None:
-            if not parameters.exists():
-                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 = loads(f.read())
-                    except 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-0.0.12/oceanprotocol_job_details/dataclasses/ocean.py

@@ -1,67 +0,0 @@
-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.12/oceanprotocol_job_details/job_details.py

@@ -1,40 +0,0 @@
-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
-
-# Logging setup for the module
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(threadName)s] [%(levelname)s]  %(message)s",
-    handlers=[logging.StreamHandler()],
-)
-
-_Implementations = Literal["env"]
-
-
-class OceanProtocolJobDetails(Loader[JobDetails]):
-    """Decorator that loads the JobDetails from the given implementation"""
-
-    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()
-
-
-del _Implementations

oceanprotocol_job_details-0.0.12/oceanprotocol_job_details/loaders/impl/map.py

@@ -1,120 +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"""
-
-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)
-class Keys:
-    """Environment keys passed to the algorithm"""
-
-    ROOT_FOLDER = "ROOT_FOLDER"
-    SECRET: str = "secret"
-    ALGORITHM: str = "TRANSFORMATION_DID"
-    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):
-    files = service[DidKeys.FILES]
-    if isinstance(files, str):
-        return [files]
-    return files
-
-
-@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) -> None:
-        self._mapper = mapper
-        self._keys = keys
-
-        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:
-        return self._from_dids(self._dids())
-
-    def _from_dids(self, dids: Sequence[str]) -> JobDetails:
-        return JobDetails(
-            dids=dids,
-            files=self._files(dids),
-            algorithm=self._algorithm(),
-            secret=self._secret(),
-        )
-
-    def _dids(self) -> Sequence[str]:
-        return loads(self._mapper.get(self._keys.DIDS, []))
-
-    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[str]]
-        :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:
-            # 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 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
-                    files[did] = [ddo_path / str(idx) for idx in range(files_n)]
-        return files
-
-    def _algorithm(self) -> Optional[Algorithm]:
-        did = self._mapper.get(self._keys.ALGORITHM, None)
-        if not did:
-            return None
-
-        ddo = Paths.DDOS / did
-
-        return Algorithm(
-            did,
-            do(lambda: ddo.exists() and ddo, exc=FileNotFoundError("Missing DDO file")),
-        )
-
-    def _secret(self) -> Optional[str]:
-        return self._mapper.get(self._keys.SECRET, None)

oceanprotocol_job_details-0.0.12/oceanprotocol_job_details/loaders/impl/utils.py

@@ -1,57 +0,0 @@
-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-0.0.12/oceanprotocol_job_details/loaders/loader.py

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