oceanprotocol-job-details 0.2.8__tar.gz → 0.3.1__tar.gz

{oceanprotocol_job_details-0.2.8 → oceanprotocol_job_details-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oceanprotocol-job-details
-Version: 0.2.8
+Version: 0.3.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,11 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: dataclasses-json>=0.6.7
+Requires-Dist: aiofiles>=25.1.0
 Requires-Dist: dependency-injector>=4.48.2
 Requires-Dist: orjson>=3.11.3
+Requires-Dist: pydantic-settings>=2.12.0
+Requires-Dist: pydantic>=2.12.5
 Description-Content-Type: text/markdown
 
 A Python package to get details from OceanProtocol jobs

oceanprotocol_job_details-0.3.1/oceanprotocol_job_details/__init__.py

@@ -0,0 +1,4 @@
+from .ocean import JobDetails
+
+
+__all__ = [JobDetails]  # type: ignore

oceanprotocol_job_details-0.3.1/oceanprotocol_job_details/di.py

@@ -0,0 +1,39 @@
+from typing import Generic, TypeVar
+from dependency_injector import containers, providers
+from pydantic import BaseModel
+
+from oceanprotocol_job_details.loaders.impl.ddo import DDOLoader
+from oceanprotocol_job_details.loaders.impl.files import FilesLoader
+from oceanprotocol_job_details.loaders.impl.job_details import JobDetailsLoader
+from oceanprotocol_job_details.domain import Paths
+
+
+InputParametersT = TypeVar("InputParametersT", bound=BaseModel)
+
+
+class Container(containers.DeclarativeContainer, Generic[InputParametersT]):
+    config = providers.Configuration()
+
+    paths = providers.Singleton(Paths, base_dir=config.base_dir)
+
+    file_loader = providers.Singleton(
+        FilesLoader,
+        dids=config.dids,
+        transformation_did=config.transformation_did,
+        paths=paths,
+        logger=config.logger,
+    )
+
+    files = providers.Factory(lambda loader: loader.load(), loader=file_loader)
+    ddo_loader = providers.Factory(DDOLoader, files=files)
+    ddos = providers.Factory(lambda loader: loader.load(), loader=ddo_loader)
+
+    job_details_loader: providers.Factory[JobDetailsLoader[InputParametersT]] = (
+        providers.Factory(
+            JobDetailsLoader,
+            files=files,
+            secret=config.secret,
+            paths=paths,
+            ddos=ddos,
+        )
+    )

oceanprotocol_job_details-0.3.1/oceanprotocol_job_details/domain.py

@@ -0,0 +1,187 @@
+# mypy: disable-error-code=explicit-any
+from dataclasses import InitVar, dataclass, field
+from pathlib import Path
+from typing import Generator, List, Optional, Sequence, TypeAlias, TypeVar
+
+from pydantic import BaseModel, ConfigDict, Field, JsonValue
+
+
+class Credential(BaseModel):
+    type: str
+    values: list[str]
+
+
+class Credentials(BaseModel):
+    allow: list[Credential]
+    deny: list[Credential]
+
+
+class DockerContainer(BaseModel):
+    image: str
+    tag: str
+    entrypoint: str
+
+
+class Algorithm(BaseModel):
+    container: DockerContainer
+    language: str
+    version: str
+    consumerParameters: JsonValue
+
+
+class Metadata(BaseModel):
+    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
+
+
+class ConsumerParameters(BaseModel):
+    name: str
+    type: str
+    label: str
+    required: bool
+    description: str
+    default: str
+    option: Optional[list[str]] = None
+
+
+class Service(BaseModel):
+    id: str
+    type: str
+    timeout: int
+    files: str
+    datatokenAddress: str
+    serviceEndpoint: str
+    additionalInformation: Optional[str] = None
+    name: Optional[str] = None
+    description: Optional[str] = None
+
+
+class Event(BaseModel):
+    tx: str
+    block: int
+    from_: str = Field(alias="from")
+    contract: str
+    datetime: str
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+class NFT(BaseModel):
+    address: str
+    name: str
+    symbol: str
+    state: int
+    tokenURI: str
+    owner: str
+    created: str
+
+
+class DataToken(BaseModel):
+    address: str
+    name: str
+    symbol: str
+    serviceId: str
+
+
+class Price(BaseModel):
+    value: int
+
+
+class Stats(BaseModel):
+    allocated: int
+    orders: int
+    price: Price
+
+
+class Purgatory(BaseModel):
+    state: bool
+
+
+class DDO(BaseModel):
+    id: str
+    context: list[str] = Field(alias="@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
+
+    model_config = ConfigDict(populate_by_name=True)
+
+
+@dataclass(frozen=True)
+class DIDPaths:
+    did: str
+    ddo: Path = field(repr=False)
+
+    files: InitVar[Generator[Path, None, None]]
+
+    _input: List[Path] = field(init=False, repr=False)
+
+    def __post_init__(self, files: Generator[Path, None, None]) -> None:
+        assert self.ddo.exists(), f"DDO {self.ddo} does not exist"
+
+        object.__setattr__(self, "_input", list(files))
+
+    @property
+    def input_files(self) -> List[Path]:
+        return self._input
+
+    def __len__(self) -> int:
+        return len(self._input)
+
+
+Files: TypeAlias = Sequence[DIDPaths]
+
+
+@dataclass(frozen=True)
+class Paths:
+    """Configuration class for the Ocean Protocol Job Details"""
+
+    base_dir: InitVar[Path | None] = None
+
+    _base: Path = field(init=False, repr=False)
+
+    def __post_init__(self, base_dir: Path | None) -> None:
+        object.__setattr__(self, "_base", base_dir if base_dir else Path("/data"))
+
+    @property
+    def data(self) -> Path:
+        return self._base
+
+    @property
+    def inputs(self) -> Path:
+        return self.data / "inputs"
+
+    @property
+    def ddos(self) -> Path:
+        return self.data / "ddos"
+
+    @property
+    def outputs(self) -> Path:
+        return self.data / "outputs"
+
+    @property
+    def logs(self) -> Path:
+        return self.data / "logs"
+
+    @property
+    def algorithm_custom_parameters(self) -> Path:
+        return self.inputs / "algoCustomData.json"

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

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from dataclasses import InitVar, dataclass, field
+from pathlib import Path
+from typing import final
+
+from oceanprotocol_job_details.domain import DDO, Files
+
+
+@final
+@dataclass(frozen=True)
+class DDOLoader:
+    files: InitVar[Files]
+    """The files to load the DDOs from"""
+
+    _ddo_paths: list[Path] = field(init=False)
+
+    def __post_init__(self, files: Files) -> None:
+        assert files is not None and len(files) != 0, "Missing files"
+
+        object.__setattr__(self, "_ddo_paths", [f.ddo for f in files])
+
+    def load(self) -> list[DDO]:
+        return [DDO.model_validate_json(p.read_text()) for p in self._ddo_paths]

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

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import InitVar, dataclass, field
+from logging import Logger
+from pathlib import Path
+from typing import Literal, final
+
+from oceanprotocol_job_details.domain import DIDPaths, Files, Paths
+
+
+@final
+@dataclass(frozen=True)
+class FilesLoader:
+    paths: Paths
+    """Path configurations of the project"""
+
+    logger: Logger = field(repr=False)
+    """Logger to use"""
+
+    dids: list[str]
+    """Input DIDs"""
+
+    transformation_did: InitVar[str | None] = None
+    """DID for the transformation algorithm"""
+
+    _transformation_did: str = field(init=False)
+
+    def __post_init__(self, transformation_did: str | None) -> None:
+        object.__setattr__(self, "_transformation_did", transformation_did)
+
+        assert self.dids, "Missing input DIDs"
+
+    def calculate_path(self, did: str, path_type: Literal["input", "ddo"]) -> Path:
+        match path_type:
+            case "ddo":
+                return self.paths.ddos / did
+            case "input":
+                return self.paths.inputs / did
+
+    def load(self) -> Files:
+        return [
+            DIDPaths(
+                did=did,
+                ddo=self.calculate_path(did, "ddo"),
+                files=self.calculate_path(did, "input").iterdir(),
+            )
+            for did in self.dids
+        ]

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

@@ -0,0 +1,28 @@
+from dataclasses import dataclass, field
+from typing import Generic, Type, TypeVar, final
+
+from pydantic import BaseModel
+
+from oceanprotocol_job_details.domain import DDO, Files, Paths
+from oceanprotocol_job_details.ocean import JobDetails
+
+T = TypeVar("T", bound=BaseModel)
+
+
+@final
+@dataclass(frozen=True)
+class JobDetailsLoader(Generic[T]):
+    input_type: Type[T] = field(repr=False)
+    files: Files
+    secret: str
+    paths: Paths
+    ddos: list[DDO]
+
+    def load(self) -> JobDetails[T]:
+        return JobDetails[T](
+            files=self.files,
+            secret=self.secret,
+            ddos=self.ddos,
+            paths=self.paths,
+            input_type=self.input_type,
+        )

{oceanprotocol_job_details-0.2.8 → oceanprotocol_job_details-0.3.1}/oceanprotocol_job_details/loaders/loader.py

@@ -4,10 +4,6 @@ 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.3.1/oceanprotocol_job_details/ocean.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import asyncio
+from functools import cached_property
+from pathlib import Path
+from typing import Generator, Generic, Tuple, Type, TypeVar, final
+
+import aiofiles
+from pydantic import BaseModel, ConfigDict, Secret, model_validator
+
+from oceanprotocol_job_details.domain import DDO, Files, Paths
+
+InputParemetersT = TypeVar("InputParemetersT", bound=BaseModel)
+
+
+@final
+class JobDetails(BaseModel, Generic[InputParemetersT]):  # type: ignore[explicit-any]
+    files: Files
+    ddos: list[DDO]
+    paths: Paths
+    input_type: Type[InputParemetersT]
+    secret: Secret[str] | None = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, frozen=True)
+
+    @model_validator(mode="after")
+    def validate_type(self) -> JobDetails[InputParemetersT]:
+        assert issubclass(self.input_type, BaseModel), (
+            f"{self.input_type} must be subtype of pydantic.BaseModel"
+        )
+        return self
+
+    def inputs(self) -> Generator[Tuple[int, Path], None, None]:
+        yield from (
+            (idx, file)
+            for idx, files in enumerate(self.files)
+            for file in files.input_files
+        )
+
+    @cached_property
+    def input_parameters(self) -> InputParemetersT:
+        return asyncio.run(self.ainput_parameters())
+
+    async def ainput_parameters(self) -> InputParemetersT:
+        path = self.paths.algorithm_custom_parameters
+        async with aiofiles.open(path) as f:
+            raw = await f.read()
+
+        raw = raw.strip()
+        assert raw is not None, f"Empty file {path}"
+        return self.input_type.model_validate_json(raw)

oceanprotocol_job_details-0.3.1/oceanprotocol_job_details/settings.py

@@ -0,0 +1,31 @@
+# mypy: disable-error-code=call-overload
+from logging import Logger, getLogger
+from pathlib import Path
+
+import orjson
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class JobSettings(BaseSettings):  # type: ignore[explicit-any]
+    base_dir: Path = Field(alias="BASE_DIR")
+    dids: list[str] = Field(alias="DIDS")
+    transformation_did: str = Field(alias="TRANSFORMATION_DID")
+    secret: str | None = Field(default=None, alias="SECRET")
+    logger: Logger = Field(default_factory=lambda: getLogger(__name__))
+
+    model_config = SettingsConfigDict(
+        extra="forbid",
+        validate_default=True,
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+    )
+
+    @field_validator("dids", mode="before")
+    @classmethod
+    def split_dids(cls, v: list[str] | str) -> list[str]:
+        if isinstance(v, str):
+            data = orjson.loads(v)
+            assert isinstance(data, list)
+            return data
+        return v

{oceanprotocol_job_details-0.2.8 → oceanprotocol_job_details-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oceanprotocol-job-details"
-version = "0.2.8"
+version = "0.3.1"
 description = "A Python package to get details from OceanProtocol jobs"
 authors = [
     { name = "Agrospai", email = "agrospai@udl.cat" },
@@ -15,9 +15,11 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 ]
 dependencies = [
-    "dataclasses-json>=0.6.7",
+    "aiofiles>=25.1.0",
     "dependency-injector>=4.48.2",
     "orjson>=3.11.3",
+    "pydantic>=2.12.5",
+    "pydantic-settings>=2.12.0",
 ]
 
 [project.urls]
@@ -25,7 +27,7 @@ Homepage = "https://github.com/AgrospAI/oceanprotocol-job-details"
 Issues = "https://github.com/AgrospAI/oceanprotocol-job-details/issues"
 
 [tool.pytest.ini_options]
-log_level = "DEBUG"
+log_level = "INFO"
 pythonpath = "oceanprotocol_job_details"
 log_cli = true
 
@@ -40,9 +42,10 @@ include = ["oceanprotocol_job_details"]
 include = ["oceanprotocol_job_details"]
 
 [tool.mypy]
+plugins = ["pydantic.mypy"]
 strict = true
 warn_return_any = true
 disallow_any_explicit = true
 
 [dependency-groups]
-dev = ["mypy>=1.15.0", "pytest>=8.3.4"]
+dev = ["mypy>=1.15.0", "pytest>=8.3.4", "types-aiofiles>=25.1.0.20251011"]

oceanprotocol_job_details-0.2.8/oceanprotocol_job_details/__init__.py

@@ -1,4 +0,0 @@
-from .ocean import JobDetails
-
-
-__all__ = [JobDetails]

oceanprotocol_job_details-0.2.8/oceanprotocol_job_details/di.py

@@ -1,48 +0,0 @@
-from dependency_injector import containers, providers
-
-from oceanprotocol_job_details.loaders.impl.ddo import DDOLoader
-from oceanprotocol_job_details.loaders.impl.files import FilesLoader
-from oceanprotocol_job_details.loaders.impl.job_details import JobDetailsLoader
-from oceanprotocol_job_details.paths import Paths
-
-
-class Container(containers.DeclarativeContainer):
-
-    config = providers.Configuration()
-
-    paths = providers.Singleton(
-        Paths,
-        base_dir=config.base_dir,
-    )
-
-    file_loader = providers.Singleton(
-        FilesLoader,
-        dids=config.dids,
-        transformation_did=config.transformation_did,
-        paths=paths,
-        logger=config.logger,
-    )
-
-    files = providers.Factory(
-        lambda loader: loader.load(),
-        loader=file_loader,
-    )
-
-    # DDOLoader depends on Files loaded from FilesLoader
-    ddo_loader = providers.Factory(
-        DDOLoader,
-        files=files,
-    )
-
-    ddos = providers.Factory(
-        lambda loader: loader.load(),
-        loader=ddo_loader,
-    )
-
-    job_details_loader = providers.Factory(
-        JobDetailsLoader,
-        files=files,
-        secret=config.secret,
-        paths=paths,
-        ddos=ddos,
-    )

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

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

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

@@ -1,64 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import InitVar, dataclass, field
-from logging import Logger
-from typing import TYPE_CHECKING, final
-
-from oceanprotocol_job_details.paths import Paths
-
-if TYPE_CHECKING:
-    from oceanprotocol_job_details.ocean import DIDPaths, Files
-
-
-@final
-@dataclass(frozen=True)
-class FilesLoader:
-
-    dids: InitVar[str | None]
-    """Input DIDs"""
-
-    transformation_did: InitVar[str | None]
-    """DID for the transformation algorithm"""
-
-    paths: Paths
-    """Path configurations of the project"""
-
-    logger: Logger
-    """Logger to use"""
-
-    _dids: str = field(init=False)
-    _transformation_did: str = field(init=False)
-
-    def __post_init__(
-        self,
-        dids: str | None,
-        transformation_did: str | None,
-    ) -> None:
-        def _load_dids(dids, logger):
-            if dids:
-                return json.loads(dids)
-
-            logger.info("Missing DIDS, Inferring DIDS from input DDOs")
-            return [f.parts[-1] for f in self.paths.ddos.iterdir()]
-
-        object.__setattr__(self, "_transformation_did", transformation_did)
-        object.__setattr__(self, "_dids", _load_dids(dids, self.logger))
-
-        assert self._dids, "Missing input DIDs"
-
-    def load(self) -> Files:
-        from oceanprotocol_job_details.ocean import DIDPaths, Files
-
-        files: list[DIDPaths] = []
-        for did in self._dids:
-            base = self.paths.inputs / did
-            files.append(
-                DIDPaths(
-                    did=did,
-                    ddo=self.paths.ddos / did,
-                    input_files=list(base.iterdir()),
-                )
-            )
-
-        return Files(files)

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

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Generic, Type, TypeVar, final
-
-from oceanprotocol_job_details.paths import Paths
-
-if TYPE_CHECKING:
-    from oceanprotocol_job_details.ocean import DDO, Files, JobDetails
-
-
-T = TypeVar("T")
-
-
-@final
-@dataclass(frozen=True)
-class JobDetailsLoader(Generic[T]):
-
-    _type: Type[T] = field(repr=False)
-
-    files: Files
-    secret: str
-    paths: Paths
-    ddos: list[DDO]
-
-    def load(self) -> JobDetails[T]:
-        from oceanprotocol_job_details.ocean import JobDetails
-
-        return JobDetails(
-            files=self.files,
-            secret=self.secret,
-            ddos=self.ddos,
-            paths=self.paths,
-            _type=self._type,
-        )

oceanprotocol_job_details-0.2.8/oceanprotocol_job_details/ocean.py

@@ -1,313 +0,0 @@
-from __future__ import annotations
-
-import os
-from dataclasses import dataclass, field
-from functools import cached_property
-from logging import Logger, getLogger
-from pathlib import Path
-from typing import (
-    Any,
-    Generator,
-    Generic,
-    Iterator,
-    Optional,
-    Sequence,
-    Type,
-    TypeVar,
-    final,
-)
-
-import orjson
-from dataclasses_json import config as dc_config
-from dataclasses_json import dataclass_json
-
-from oceanprotocol_job_details.di import Container
-from oceanprotocol_job_details.paths import Paths
-
-InputParemetersT = TypeVar("InputParemetersT")
-
-
-@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 DockerContainer:
-    image: str
-    tag: str
-    entrypoint: str
-
-
-@dataclass_json
-@dataclass
-class Algorithm:  # type: ignore
-    container: DockerContainer
-    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
-
-
-@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]
-
-    @property
-    def files(self) -> Sequence[DIDPaths]:
-        return self._files
-
-    def __getitem__(self, index: int) -> DIDPaths:
-        return self.files[index]
-
-    def __iter__(self) -> Iterator[DIDPaths]:
-        return iter(self.files)
-
-    def __len__(self) -> int:
-        return len(self.files)
-
-
-def _normalize_json(value):
-    if isinstance(value, str):
-        try:
-            decoded = orjson.loads(value)
-            return _normalize_json(decoded)  # recurse if nested again
-        except orjson.JSONDecodeError:
-            return value
-    elif isinstance(value, dict):
-        return {k: _normalize_json(v) for k, v in value.items()}
-    elif isinstance(value, list):
-        return [_normalize_json(v) for v in value]
-    return value
-
-
-@final
-@dataclass_json
-@dataclass
-class _EmptyJobDetails: ...
-
-
-@final
-@dataclass_json
-@dataclass(frozen=True)
-class JobDetails(Generic[InputParemetersT]):
-    files: Files
-    """The input filepaths"""
-
-    ddos: list[DDO]
-    """list of paths to the DDOs"""
-
-    paths: Paths
-    """Configuration paths"""
-
-    # Store the type explicitly to avoid issues
-    _type: Type[InputParemetersT] = 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")
-
-    def next_path(self) -> Generator[tuple[int, Path], None, None]:
-        for idx, did_files in enumerate(self.files):
-            for file in did_files.input_files:
-                yield (idx, file)
-
-    @cached_property
-    def input_parameters(self) -> InputParemetersT:
-        """Read the input parameters and return them in an instance of the dataclass InputParemetersT"""
-
-        with open(self.paths.algorithm_custom_parameters, "r") as f:
-            raw = f.read().strip()
-            if not raw:
-                raise ValueError(
-                    f"Custom parameters file {self.paths.algorithm_custom_parameters} is empty"
-                )
-            try:
-                parsed = _normalize_json(orjson.loads(raw))
-                return dataclass_json(self._type).from_dict(parsed)  # type: ignore
-            except Exception as e:
-                raise ValueError(
-                    f"Failed to parse input paramers into {self._type.__name__}: {e}\n"
-                    f"Raw content: {raw}"
-                ) from e
-
-    @classmethod
-    def load(
-        cls,
-        _type: Type[InputParemetersT] | None = None,
-        *,
-        base_dir: str | None = None,
-        dids: str | None = None,
-        transformation_did: str | None = None,
-        secret: str | None = None,
-        logger: Logger | None = None,
-    ) -> JobDetails[InputParemetersT]:
-        """Load a JobDetails instance that holds the runtime details.
-
-        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:
-        - BASE_DIR: Base directory to read the data from, parent of the ddos, inputs, outputs and logs directories.
-        - DIDS: The DIDs of the inputs
-        - TRANSFORMATION_DID: The DID of the transformation algorithm
-        - SECRET (optional): A really secret secret
-        """
-
-        if _type is None:
-            _type = _EmptyJobDetails
-
-        container = Container()
-        container.config.from_dict(
-            {
-                "base_dir": base_dir or os.environ.get("BASE_DIR", None),
-                "dids": dids or os.environ.get("DIDS", None),
-                "transformation_did": transformation_did
-                or os.environ.get("TRANSFORMATION_DID", None),
-                "secret": secret or os.environ.get("SECRET", None),
-                "logger": logger or getLogger(__name__),
-            }
-        )
-
-        return container.job_details_loader(_type=_type).load()

oceanprotocol_job_details-0.2.8/oceanprotocol_job_details/paths.py

@@ -1,38 +0,0 @@
-from dataclasses import InitVar, dataclass, field
-from pathlib import Path
-
-
-@dataclass
-class Paths:
-    """Configuration class for the Ocean Protocol Job Details"""
-
-    base_dir: InitVar[Path | None]
-
-    _base: Path = field(init=False)
-
-    def __post_init__(self, base_dir: str | Path | None) -> None:
-        self._base = Path(base_dir) if base_dir else Path("/data")
-
-    @property
-    def data(self) -> Path:
-        return self._base
-
-    @property
-    def inputs(self) -> Path:
-        return self.data / "inputs"
-
-    @property
-    def ddos(self) -> Path:
-        return self.data / "ddos"
-
-    @property
-    def outputs(self) -> Path:
-        return self.data / "outputs"
-
-    @property
-    def logs(self) -> Path:
-        return self.data / "logs"
-
-    @property
-    def algorithm_custom_parameters(self) -> Path:
-        return self.inputs / "algoCustomData.json"