oceanprotocol-job-details 0.2.7__py3-none-any.whl → 0.3.3__py3-none-any.whl

oceanprotocol_job_details/__init__.py

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

oceanprotocol_job_details/di.py

@@ -1,21 +1,22 @@
+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.paths import Paths
+from oceanprotocol_job_details.domain import Paths
 
 
-class Container(containers.DeclarativeContainer):
+InputParametersT = TypeVar("InputParametersT", bound=BaseModel)
 
+
+class Container(containers.DeclarativeContainer, Generic[InputParametersT]):
     config = providers.Configuration()
 
-    paths = providers.Singleton(
-        Paths,
-        base_dir=config.base_dir,
-    )
+    paths = providers.Singleton(Paths, base_dir=config.base_dir)
 
-    file_loader = providers.Factory(
+    file_loader = providers.Singleton(
         FilesLoader,
         dids=config.dids,
         transformation_did=config.transformation_did,
@@ -23,26 +24,16 @@ class Container(containers.DeclarativeContainer):
         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,
+    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/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/helpers.py

@@ -0,0 +1,29 @@
+from typing import Any, Dict, Type, TypeVar
+
+from pydantic import BaseModel, JsonValue
+
+from oceanprotocol_job_details.di import Container
+from oceanprotocol_job_details.ocean import JobDetails
+from oceanprotocol_job_details.settings import JobSettings
+
+InputParametersT = TypeVar("InputParametersT", bound=BaseModel)
+
+
+def create_container(config: Dict[str, Any]) -> Container[InputParametersT]:  # type: ignore[explicit-any]
+    """Return a fully configured Container from a config dict."""
+    container = Container[InputParametersT]()
+    settings = JobSettings(**config)
+    container.config.from_pydantic(settings)
+    return container
+
+
+def load_job_details(
+    config: Dict[str, JsonValue],
+    input_type: Type[InputParametersT],
+) -> JobDetails[InputParametersT]:
+    """
+    Load JobDetails for a given input_type using the config.
+    Returns a fully initialized JobDetails instance.
+    """
+    container: Container[InputParametersT] = create_container(config)
+    return container.job_details_loader(input_type=input_type).load()

oceanprotocol_job_details/loaders/impl/ddo.py

@@ -2,31 +2,23 @@ from __future__ import annotations
 
 from dataclasses import InitVar, dataclass, field
 from pathlib import Path
-from typing import TYPE_CHECKING, final
+from typing import final
 
-if TYPE_CHECKING:
-    from oceanprotocol_job_details.ocean import DDO, Files
+from oceanprotocol_job_details.domain import DDO, Files
 
 
 @final
 @dataclass(frozen=True)
 class DDOLoader:
-
-    files: InitVar[list[Files]]
+    files: InitVar[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"
+    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]:
-        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
+        return [DDO.model_validate_json(p.read_text()) for p in self._ddo_paths]

oceanprotocol_job_details/loaders/impl/files.py

@@ -1,64 +1,44 @@
 from __future__ import annotations
 
-import json
 from dataclasses import InitVar, dataclass, field
 from logging import Logger
-from typing import TYPE_CHECKING, final
+from pathlib import Path
+from typing import Literal, final
 
-from oceanprotocol_job_details.paths import Paths
-
-if TYPE_CHECKING:
-    from oceanprotocol_job_details.ocean import DIDPaths, Files
+from oceanprotocol_job_details.domain import DIDPaths, Files, Paths
 
 
 @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: Logger = field(repr=False)
     """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)
+    dids: list[str]
+    """Input DIDs"""
 
-            logger.info("Missing DIDS, Inferring DIDS from input DDOs")
-            return [f.parts[-1] for f in self.paths.ddos.iterdir()]
+    transformation_did: str
+    """DID for the transformation algorithm"""
 
-        object.__setattr__(self, "_transformation_did", transformation_did)
-        object.__setattr__(self, "_dids", _load_dids(dids, self.logger))
+    def __post_init__(self) -> None:
+        assert self.dids, "Missing input DIDs"
 
-        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:
-        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 [
+            DIDPaths(
+                did=did,
+                ddo=self.calculate_path(did, "ddo"),
+                files=self.calculate_path(did, "input").iterdir(),
             )
-
-        return Files(files)
+            for did in self.dids
+        ]

oceanprotocol_job_details/loaders/impl/job_details.py

@@ -1,35 +1,28 @@
-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
+from typing import Generic, Type, TypeVar, final
 
-if TYPE_CHECKING:
-    from oceanprotocol_job_details.ocean import DDO, Files, JobDetails
+from pydantic import BaseModel
 
+from oceanprotocol_job_details.domain import DDO, Files, Paths
+from oceanprotocol_job_details.ocean import JobDetails
 
-T = TypeVar("T")
+T = TypeVar("T", bound=BaseModel)
 
 
 @final
 @dataclass(frozen=True)
 class JobDetailsLoader(Generic[T]):
-
-    _type: Type[T] = field(repr=False)
-
+    input_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(
+        return JobDetails[T](
             files=self.files,
             secret=self.secret,
             ddos=self.ddos,
             paths=self.paths,
-            _type=self._type,
+            input_type=self.input_type,
         )

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/ocean.py

@@ -1,313 +1,51 @@
 from __future__ import annotations
 
-import os
-from dataclasses import dataclass, field
+import asyncio
 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,
-)
+from typing import Generator, Generic, Tuple, Type, TypeVar, final
 
-import orjson
-from dataclasses_json import config as dc_config
-from dataclasses_json import dataclass_json
+import aiofiles
+from pydantic import BaseModel, ConfigDict, Secret, model_validator
 
-from oceanprotocol_job_details.di import Container
-from oceanprotocol_job_details.paths import Paths
+from oceanprotocol_job_details.domain import DDO, Files, 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
+InputParemetersT = TypeVar("InputParemetersT", bound=BaseModel)
 
 
 @final
-@dataclass_json
-@dataclass
-class _EmptyJobDetails: ...
-
-
-@final
-@dataclass_json
-@dataclass(frozen=True)
-class JobDetails(Generic[InputParemetersT]):
+class JobDetails(BaseModel, Generic[InputParemetersT]):  # type: ignore[explicit-any]
     files: Files
-    """The input filepaths"""
-
     ddos: list[DDO]
-    """list of paths to the DDOs"""
-
     paths: Paths
-    """Configuration paths"""
+    input_type: Type[InputParemetersT]
+    secret: Secret[str] | None = None
 
-    # Store the type explicitly to avoid issues
-    _type: Type[InputParemetersT] = field(repr=False)
+    model_config = ConfigDict(arbitrary_types_allowed=True, frozen=True)
 
-    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")
+    @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 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)
+    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:
-        """Read the input parameters and return them in an instance of the dataclass InputParemetersT"""
+        return asyncio.run(self.ainput_parameters())
 
-        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__),
-            }
-        )
+    async def ainput_parameters(self) -> InputParemetersT:
+        path = self.paths.algorithm_custom_parameters
+        async with aiofiles.open(path) as f:
+            raw = await f.read()
 
-        return container.job_details_loader(_type=_type).load()
+        raw = raw.strip()
+        assert raw is not None, f"Empty file {path}"
+        return self.input_type.model_validate_json(raw)

oceanprotocol_job_details/settings.py

@@ -0,0 +1,37 @@
+# mypy: disable-error-code=call-overload
+from logging import Logger, getLogger
+from pathlib import Path
+from typing import Self
+
+import orjson
+from pydantic import Field, field_validator, model_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(default_factory=list, 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",
+        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
+
+    @model_validator(mode="after")
+    def validate_dids(self) -> Self:
+        if not self.dids:
+            self.dids.extend([f.name for f in (self.base_dir / "ddos").glob("*")])
+        return self

{oceanprotocol_job_details-0.2.7.dist-info → oceanprotocol_job_details-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oceanprotocol-job-details
-Version: 0.2.7
+Version: 0.3.3
 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
@@ -28,24 +30,29 @@ A Python package to get details from OceanProtocol jobs
 
 ## Installation
 
-```
+```bash
 pip install oceanprotocol-job-details
 ```
 
-## Usage 
+```bash
+uv add oceanprotocol-job-details
+```
+
+## Usage
 
-As a simple library, we only need to import `JobDetails` and load it, it will:
+As a simple library, we only need to import `load_job_details` and run it. It will:
 
-1. Fetch the needed parameters to populate the `JobDetails` instance from the environment variables or use the passed values to the `load()` method.
+1. Fetch the needed parameters to populate the `JobDetails` instance from the environment variables or use the passed values to the function.
 1. Look for the files corresponding to the passed DIDs in the filesystem according to the [Ocean Protocol Structure](#oceanprotocol-structure) and load them into the `JobDetails` instance.
 
-
 ### Minimal Example
 
 ```python
-from oceanprotocol_job_details import JobDetails
+from oceanprotocol_job_details import load_job_details
 
-job_details = JobDetails.load()
+class InputParameters(BaseModel): ...
+
+job_details = load_job_details({}, InputParameters)
 ```
 
 ### Custom Input Parameters
@@ -53,58 +60,40 @@ job_details = JobDetails.load()
 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 import JobDetails
-
-
-@dataclass
-class InputParameters:
-    foobar: str
-
-
-job_details = JobDetails[InputParameters].load(InputParameters)
-
-# Usage
-job_details.input_parameters.foobar
-```
-
-```python
-from dataclasses import dataclass
-from oceanprotocol_job_details import JobDetails
+from pydantic import BaseModel
+from oceanprotocol_job_details import load_job_details
 
 
-@dataclass
-class Foo:
+class Foo(BaseModel):
     bar: str
 
 
-@dataclass
-class InputParameters:
+class InputParameters(BaseModel):
     # Allows for nested types
     foo: Foo
 
 
-job_details = JobDetails[InputParameters].load(InputParameters)
+job_details = load_job_details({}, InputParameters)
 
 # Usage
+job_details.input_parameters.foo
 job_details.input_parameters.foo.bar
 ```
 
-The values to fill the custom `InputParameters` will be parsed from the `algoCustomData.json` located next to the input data directories. 
+The values to fill the custom `InputParameters` will be parsed from the `algoCustomData.json` located next to the input data directories.
 
 ### Iterating Input Files the clean way
 
 ```python
-from oceanprotocol_job_details import JobDetails
+from oceanprotocol_job_details import load_job_details
 
 
-job_details = JobDetails.load()
+job_details = load_job_details
 
-for idx, file_path in job_details.next_file():
+for idx, file_path in job_details.inputs():
     ...
 
-# Or if you just want one file path
-_, file_path = job_details.next_file()
+_, file_path = next(job_details.inputs())
 ```
 
 ## OceanProtocol Structure
@@ -122,4 +111,4 @@ data        # Root /data directory
 └── outputs # Algorithm output files dir
 ```
 
-> **_Note:_** Even though it's possible that the algorithm is passed multiple datasets, right now the implementation only allows to use **one dataset** per algorithm execution, so **normally** the executing job will only have **one ddo**, **one dir** inside inputs, and **one data file** named `0`.
+> **_Note:_** Even though it's possible that the algorithm is passed multiple datasets, right now the implementation only allows to use **one dataset** per algorithm execution, so **normally** the executing job will only have **one ddo**, **one dir** inside inputs, and **one data file** named `0`.

oceanprotocol_job_details-0.3.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+oceanprotocol_job_details/__init__.py,sha256=nJMrZsEC5F1n9WF-v5QV095Yyc8UkhFw0AzD9o7X0IE,162
+oceanprotocol_job_details/di.py,sha256=lsogbmjvmPfkd0mjLvn9vYLIZebwJm5RNraWt7WE5LA,1316
+oceanprotocol_job_details/domain.py,sha256=2_USbeA_7VIEYS8DVb2MW6dCZasjiqIxQaGUnNUKspY,3851
+oceanprotocol_job_details/helpers.py,sha256=ubH_KjAROqYvn0mkbA0-89vpdKIhVNGZ0h9pQLfPNow,1045
+oceanprotocol_job_details/ocean.py,sha256=q8rgT5ycA2ifey3XNhUW0bcJwfMp7hpKU-6EVDeKV1o,1620
+oceanprotocol_job_details/settings.py,sha256=zgIYPzaXjsgcmuhT7L2ipSP-2eNaodugHZr0rn2Z420,1248
+oceanprotocol_job_details/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/loaders/loader.py,sha256=36X2s_0lN89kCUpItxEXfIzuBBNJySebP2B_tdWK2E0,186
+oceanprotocol_job_details/loaders/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oceanprotocol_job_details/loaders/impl/ddo.py,sha256=XthrQFhmP85XSVzVjBlLePtTowGR3BAsmVp3jngiQ08,668
+oceanprotocol_job_details/loaders/impl/files.py,sha256=Y2vFBT2T9w9zrdpmf550-LQJxwtNPUGa0UU6bBzk9AU,1145
+oceanprotocol_job_details/loaders/impl/job_details.py,sha256=7mEdeTo-cmsWuqWPdN7btjLjo6p5Oa1_acjSLWL5tb8,697
+oceanprotocol_job_details-0.3.3.dist-info/METADATA,sha256=pDXdsInFTf36wYjsqWSd_ygeCDggozjueHlhF6OyvlQ,4416
+oceanprotocol_job_details-0.3.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+oceanprotocol_job_details-0.3.3.dist-info/licenses/LICENSE,sha256=ni3ix7P_GxK1W3VGC4fJ3o6QoCngCEpSuTJwO4nkpbw,1055
+oceanprotocol_job_details-0.3.3.dist-info/RECORD,,

{oceanprotocol_job_details-0.2.7.dist-info → oceanprotocol_job_details-0.3.3.dist-info}/WHEEL

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

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"

oceanprotocol_job_details-0.2.7.dist-info/RECORD

@@ -1,14 +0,0 @@
-oceanprotocol_job_details/__init__.py,sha256=C67wv7fy5ZT5FtbGD-oQeSoLU-x6e2ts-820koFo034,55
-oceanprotocol_job_details/di.py,sha256=PE6FGLRZPLDx-J7FfutCNES7sqpZA8e6jdu4tNe-AjQ,1210
-oceanprotocol_job_details/ocean.py,sha256=t1BP4bdIcNgzEkXuVM7g9Bg0pEz_ljctE2CQEtSPnwA,7431
-oceanprotocol_job_details/paths.py,sha256=o2IwhKO8nxIp03-NXYUhhWC7XPiMjz61AACStZRcJX0,877
-oceanprotocol_job_details/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oceanprotocol_job_details/loaders/loader.py,sha256=HIzsVKCuGP7ghfM7ppN3ANVybvsA64wr3h8I68mqS6A,195
-oceanprotocol_job_details/loaders/impl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oceanprotocol_job_details/loaders/impl/ddo.py,sha256=SuPvQBc2MS-q0g8BQOfCXPAvMvhl7Vnbq9GHugAU--s,828
-oceanprotocol_job_details/loaders/impl/files.py,sha256=ZiIb-gblgIqU5HBy0mrZwooH-Qu_HSWyaJ3VtBIhJcs,1696
-oceanprotocol_job_details/loaders/impl/job_details.py,sha256=wf0xNAG4tESq57vqkdtMQ8BdiyS91j5f7FL8Gfwbjh4,770
-oceanprotocol_job_details-0.2.7.dist-info/METADATA,sha256=uuxmkYSbZFKGb01Ng_miulyrUv4cx0Djv0Obte575dk,4507
-oceanprotocol_job_details-0.2.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-oceanprotocol_job_details-0.2.7.dist-info/licenses/LICENSE,sha256=ni3ix7P_GxK1W3VGC4fJ3o6QoCngCEpSuTJwO4nkpbw,1055
-oceanprotocol_job_details-0.2.7.dist-info/RECORD,,