ocean-runner 0.2.12__tar.gz → 0.2.19__tar.gz

{ocean_runner-0.2.12 → ocean_runner-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ocean-runner
-Version: 0.2.12
+Version: 0.2.19
 Summary: A fluent API for OceanProtocol algorithms
 Project-URL: Homepage, https://github.com/AgrospAI/ocean-runner
 Project-URL: Issues, https://github.com/AgrospAI/ocean-runner/issues
@@ -17,13 +17,15 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: oceanprotocol-job-details>=0.2.7
+Requires-Dist: oceanprotocol-job-details>=0.2.8
+Requires-Dist: pydantic-settings>=2.12.0
+Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pytest>=8.4.2
 Description-Content-Type: text/markdown
 
 # ocean-runner
 
-Ocean Runner is a package that brings a fluent API for APP creation and running in the scope of OceanProtocol.
+Ocean Runner is a package that eases algorithm creation in the scope of OceanProtocol.
 
 
 ## Installation
@@ -40,33 +42,40 @@ uv add ocean-runner
 
 ```python
 import random
-from ocean_runner import Algorithm, Config
+from ocean_runner import Algorithm
+
+algorithm = Algorithm()
+
 
+@algorithm.run
+def run():
+    return random.randint()
 
-Algorithm().run(lambda _: random.randint()).save_results()    
+
+if __name__ == "__main__":
+    algorithm()
 ```
 
-To use minimally the API, you can just provide a callback to the run method, defaulting for the rest of behaviours. This code snippet will:
+This code snippet will:
 
-- Read the OceanProtocol JobDetails from the environment variables and use default file paths.
-- Generate a random integer.
-- Store the result in a "result.txt" file within the default outputs path.
+- Read the OceanProtocol JobDetails from the environment variables and use default configuration file paths.
+- Execute the run function.
+- Execute the default saving function, storing the result in a "result.txt" file within the default outputs path.
 
 ### Tuning
 
 #### Application Config
 
-The application configuration can be tweaked by passing a Config instance to its' constructor.
+The application configuration can be tweaked by passing a Config instance to its constructor.
 
 ```python
-Algorithm(
+from ocean_runner import Algorithm, Config
+
+algorithm = Algorithm(
     Config(
         custom_input: ... # dataclass
         # Custom algorithm parameters dataclass.
         
-        error_callback: ... # Callable[[Exception], None]
-        # Callback to run on exceptions.
-        
         logger: ... # type: logging.Logger
         # Custom logger to use.
 
@@ -82,6 +91,8 @@ Algorithm(
 ```python
 import logging
 
+from ocean_runner import Algorithm, Config
+
 
 @dataclass
 class CustomInput:
@@ -91,19 +102,13 @@ class CustomInput:
 logger = logging.getLogger(__name__)
 
 
-Algorithm(
+algorithm = Algorithm(
     Config(
         custom_input: CustomInput,
         """
         Load the Algorithm's Custom Input into a CustomInput dataclass instance.
         """
 
-        error_callback: lambda ex: logger.exception(ex),
-        """
-        Run this callback when an exception is caught
-        NOTE: it's not recommended to catch exceptions this way. Should re-raise and halt the execution.
-        """
-
         source_paths: [Path("/algorithm/src")],
         """
         Source paths to include in the PATH. '/algorithm/src' is the default since our templates place the algorithm source files there.
@@ -143,44 +148,72 @@ Algorithm(
 
 ```
 
-## Default behaviours
+#### Behaviour Config
 
-### Default implementations
-
-As seen in the minimal example, all methods implemented in `Algorithm` have a default implementation which will be commented here.
+To fully configure the behaviour of the algorithm as in the [Minimal Example](#minimal-example), you can do it decorating your defined function as in the following example, which features all the possible algorithm customization.
 
 ```python
+from pathlib import Path
 
-(
-    Algorithm()
-    
-        """
-        Default constructor, will use default values of Config.
-        """
-    
-    .validate()
-    
-        """
-        Will validate the algorithm's job detail instance, checking for the existence of:
-        - `job_details.ddos` 
-        - `job_details.files`
-        """
+import pandas as pd
+from ocean_runner import Algorithm
 
-    .run()
+algorithm = Algorithm()
 
-        """ 
-        Has NO default implementation, must pass a callback that returns a result of any type.
-        """
 
-    .save_results()
+@algorithm.on_error
+def error_callback(ex: Exception):
+    algorithm.logger.exception(ex)
+    raise algorithm.Error() from ex
 
-        """
-        Stores the result of running the algorithm in "outputs/results.txt"
-        """
 
-)
+@algorithm.validate
+def val():
+    assert algorithm.job_details.files, "Empty input dir"
+
+
+@algorithm.run
+def run() -> pd.DataFrame:
+    _, filename = next(algorithm.job_details.next_path())
+    return pd.read_csv(filename).describe(include="all")
+
+
+@algorithm.save_results
+def save(results: pd.DataFrame, path: Path):
+    algorithm.logger.info(f"Descriptive statistics: {results}")
+    results.to_csv(path / "results.csv")
+
+
+if __name__ == "__main__":
+    algorithm()
+```
+
+
+
+### Default implementations
+
+As seen in the minimal example, all methods implemented in `Algorithm` have a default implementation which will be commented here.
+
+```python
+.validate()
+
+    """
+    Will validate the algorithm's job detail instance, checking for the existence of:
+    - `job_details.ddos`
+    - `job_details.files`
+    """
+
+.run()
+
+    """ 
+    Has NO default implementation, must pass a callback that returns a result of any type.
+    """
 
+.save_results()
 
+    """
+    Stores the result of running the algorithm in "outputs/results.txt"
+    """
 ```
 
 ### Job Details
@@ -188,7 +221,7 @@ As seen in the minimal example, all methods implemented in `Algorithm` have a de
 To load the OceanProtocol JobDetails instance, the program will read some environment variables, they can be mocked passing an instance of `Environment` through the configuration of the algorithm.
 
 Environment variables:
-- `DIDS` Input dataset(s) DID's, must have format: `["abc..90"]`
-- `TRANSFORMATION_DID` Algorithm DID, must have format: `abc..90`
-- `SECRET` Algorithm secret.
+- `DIDS` (optional) Input dataset(s) DID's, must have format: `["abc..90"]`. Defaults to reading them automatically from the `DDO` data directory.
+- `TRANSFORMATION_DID` (optional, default="DEFAULT"): Algorithm DID, must have format: `abc..90`.
+- `SECRET` (optional, default="DEFAULT"): Algorithm secret. 
 - `BASE_DIR` (optional, default="/data"): Base path to the OceanProtocol data directories.

{ocean_runner-0.2.12 → ocean_runner-0.2.19}/README.md

@@ -1,6 +1,6 @@
 # ocean-runner
 
-Ocean Runner is a package that brings a fluent API for APP creation and running in the scope of OceanProtocol.
+Ocean Runner is a package that eases algorithm creation in the scope of OceanProtocol.
 
 
 ## Installation
@@ -17,33 +17,40 @@ uv add ocean-runner
 
 ```python
 import random
-from ocean_runner import Algorithm, Config
+from ocean_runner import Algorithm
+
+algorithm = Algorithm()
+
 
+@algorithm.run
+def run():
+    return random.randint()
 
-Algorithm().run(lambda _: random.randint()).save_results()    
+
+if __name__ == "__main__":
+    algorithm()
 ```
 
-To use minimally the API, you can just provide a callback to the run method, defaulting for the rest of behaviours. This code snippet will:
+This code snippet will:
 
-- Read the OceanProtocol JobDetails from the environment variables and use default file paths.
-- Generate a random integer.
-- Store the result in a "result.txt" file within the default outputs path.
+- Read the OceanProtocol JobDetails from the environment variables and use default configuration file paths.
+- Execute the run function.
+- Execute the default saving function, storing the result in a "result.txt" file within the default outputs path.
 
 ### Tuning
 
 #### Application Config
 
-The application configuration can be tweaked by passing a Config instance to its' constructor.
+The application configuration can be tweaked by passing a Config instance to its constructor.
 
 ```python
-Algorithm(
+from ocean_runner import Algorithm, Config
+
+algorithm = Algorithm(
     Config(
         custom_input: ... # dataclass
         # Custom algorithm parameters dataclass.
         
-        error_callback: ... # Callable[[Exception], None]
-        # Callback to run on exceptions.
-        
         logger: ... # type: logging.Logger
         # Custom logger to use.
 
@@ -59,6 +66,8 @@ Algorithm(
 ```python
 import logging
 
+from ocean_runner import Algorithm, Config
+
 
 @dataclass
 class CustomInput:
@@ -68,19 +77,13 @@ class CustomInput:
 logger = logging.getLogger(__name__)
 
 
-Algorithm(
+algorithm = Algorithm(
     Config(
         custom_input: CustomInput,
         """
         Load the Algorithm's Custom Input into a CustomInput dataclass instance.
         """
 
-        error_callback: lambda ex: logger.exception(ex),
-        """
-        Run this callback when an exception is caught
-        NOTE: it's not recommended to catch exceptions this way. Should re-raise and halt the execution.
-        """
-
         source_paths: [Path("/algorithm/src")],
         """
         Source paths to include in the PATH. '/algorithm/src' is the default since our templates place the algorithm source files there.
@@ -120,44 +123,72 @@ Algorithm(
 
 ```
 
-## Default behaviours
+#### Behaviour Config
 
-### Default implementations
-
-As seen in the minimal example, all methods implemented in `Algorithm` have a default implementation which will be commented here.
+To fully configure the behaviour of the algorithm as in the [Minimal Example](#minimal-example), you can do it decorating your defined function as in the following example, which features all the possible algorithm customization.
 
 ```python
+from pathlib import Path
 
-(
-    Algorithm()
-    
-        """
-        Default constructor, will use default values of Config.
-        """
-    
-    .validate()
-    
-        """
-        Will validate the algorithm's job detail instance, checking for the existence of:
-        - `job_details.ddos` 
-        - `job_details.files`
-        """
+import pandas as pd
+from ocean_runner import Algorithm
 
-    .run()
+algorithm = Algorithm()
 
-        """ 
-        Has NO default implementation, must pass a callback that returns a result of any type.
-        """
 
-    .save_results()
+@algorithm.on_error
+def error_callback(ex: Exception):
+    algorithm.logger.exception(ex)
+    raise algorithm.Error() from ex
 
-        """
-        Stores the result of running the algorithm in "outputs/results.txt"
-        """
 
-)
+@algorithm.validate
+def val():
+    assert algorithm.job_details.files, "Empty input dir"
+
+
+@algorithm.run
+def run() -> pd.DataFrame:
+    _, filename = next(algorithm.job_details.next_path())
+    return pd.read_csv(filename).describe(include="all")
+
+
+@algorithm.save_results
+def save(results: pd.DataFrame, path: Path):
+    algorithm.logger.info(f"Descriptive statistics: {results}")
+    results.to_csv(path / "results.csv")
+
+
+if __name__ == "__main__":
+    algorithm()
+```
+
+
+
+### Default implementations
+
+As seen in the minimal example, all methods implemented in `Algorithm` have a default implementation which will be commented here.
+
+```python
+.validate()
+
+    """
+    Will validate the algorithm's job detail instance, checking for the existence of:
+    - `job_details.ddos`
+    - `job_details.files`
+    """
+
+.run()
+
+    """ 
+    Has NO default implementation, must pass a callback that returns a result of any type.
+    """
 
+.save_results()
 
+    """
+    Stores the result of running the algorithm in "outputs/results.txt"
+    """
 ```
 
 ### Job Details
@@ -165,7 +196,7 @@ As seen in the minimal example, all methods implemented in `Algorithm` have a de
 To load the OceanProtocol JobDetails instance, the program will read some environment variables, they can be mocked passing an instance of `Environment` through the configuration of the algorithm.
 
 Environment variables:
-- `DIDS` Input dataset(s) DID's, must have format: `["abc..90"]`
-- `TRANSFORMATION_DID` Algorithm DID, must have format: `abc..90`
-- `SECRET` Algorithm secret.
+- `DIDS` (optional) Input dataset(s) DID's, must have format: `["abc..90"]`. Defaults to reading them automatically from the `DDO` data directory.
+- `TRANSFORMATION_DID` (optional, default="DEFAULT"): Algorithm DID, must have format: `abc..90`.
+- `SECRET` (optional, default="DEFAULT"): Algorithm secret. 
 - `BASE_DIR` (optional, default="/data"): Base path to the OceanProtocol data directories.

{ocean_runner-0.2.12 → ocean_runner-0.2.19}/ocean_runner/__init__.py

@@ -1,4 +1,4 @@
 from ocean_runner.config import Config, Environment
 from ocean_runner.runner import Algorithm
 
-__all__ = [Config, Algorithm, Environment]
+__all__ = [Config, Algorithm, Environment]  # type: ignore

ocean_runner-0.2.19/ocean_runner/config.py

@@ -0,0 +1,71 @@
+from enum import StrEnum, auto
+from logging import Logger
+from pathlib import Path
+from typing import Generic, Sequence, TypeVar
+
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic_settings import BaseSettings
+
+InputT = TypeVar("InputT")
+
+DEFAULT = "DEFAULT"
+
+
+class Keys(StrEnum):
+    SECRET = auto()
+    BASE_DIR = auto()
+    TRANSFORMATION_DID = auto()
+    DIDS = auto()
+
+
+class Environment(BaseSettings):
+    """Environment configuration loaded from environment variables"""
+
+    base_dir: str | Path | None = Field(
+        default_factory=lambda: Path("/data"),
+        validation_alias=Keys.BASE_DIR.value,
+        description="Base data directory, defaults to '/data'",
+    )
+
+    dids: str | list[Path] | None = Field(
+        default=None,
+        validation_alias=Keys.DIDS.value,
+        description='Datasets DID\'s, format: ["XXXX"]',
+    )
+
+    transformation_did: str = Field(
+        default=DEFAULT,
+        validation_alias=Keys.TRANSFORMATION_DID.value,
+        description="Transformation (algorithm) DID",
+    )
+
+    secret: str = Field(
+        default=DEFAULT,
+        validation_alias=Keys.SECRET.value,
+        description="Super secret secret",
+    )
+
+
+class Config(BaseModel, Generic[InputT]):
+    """Algorithm overall configuration"""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    custom_input: InputT | None = Field(
+        default=None,
+        description="Algorithm's custom input types, must be a dataclass_json",
+    )
+
+    logger: Logger | None = Field(
+        default=None,
+        description="Logger to use in the algorithm",
+    )
+
+    source_paths: Sequence[Path] = Field(
+        default_factory=lambda: [Path("/algorithm/src")],
+        description="Paths that should be included so the code executes correctly",
+    )
+
+    environment: Environment = Field(
+        default_factory=Environment, description="Environment configuration"
+    )

ocean_runner-0.2.19/ocean_runner/runner.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from dataclasses import InitVar, asdict, dataclass, field
+from logging import Logger
+from pathlib import Path
+from typing import Callable, Generic, TypeVar
+
+from oceanprotocol_job_details import JobDetails  # type: ignore
+
+from ocean_runner.config import Config
+
+InputT = TypeVar("InputT")
+ResultT = TypeVar("ResultT")
+
+ValidateFuncT = Callable[["Algorithm"], None]
+RunFuncT = Callable[["Algorithm"], ResultT] | None
+SaveFuncT = Callable[["Algorithm", ResultT, Path], None]
+ErrorFuncT = Callable[["Algorithm", Exception], None]
+
+
+def default_error_callback(algorithm: Algorithm, e: Exception) -> None:
+    algorithm.logger.exception("Error during algorithm execution")
+    raise e
+
+
+def default_validation(algorithm: Algorithm) -> None:
+    algorithm.logger.info("Validating input using default validation")
+    assert algorithm.job_details.ddos, "DDOs missing"
+    assert algorithm.job_details.files, "Files missing"
+
+
+def default_save(algorithm: Algorithm, result: ResultT, base: Path) -> None:
+    algorithm.logger.info("Saving results using default save")
+    with open(base / "result.txt", "w+") as f:
+        f.write(str(result))
+
+
+@dataclass
+class Algorithm(Generic[InputT, ResultT]):
+    """
+    A configurable algorithm runner that behaves like a FastAPI app:
+      - You register `validate`, `run`, and `save_results` via decorators.
+      - You execute the full pipeline by calling `app()`.
+    """
+
+    config: InitVar[Config[InputT] | None] = field(default=None)
+    logger: Logger = field(init=False)
+    _job_details: JobDetails[InputT] = field(init=False)
+    _result: ResultT | None = field(default=None, init=False)
+
+    # Decorator-registered callbacks
+    _validate_fn: ValidateFuncT = field(
+        default=default_validation,
+        init=False,
+        repr=False,
+    )
+
+    _run_fn: RunFuncT = field(
+        default=None,
+        init=False,
+        repr=False,
+    )
+
+    _save_fn: SaveFuncT = field(
+        default=default_save,
+        init=False,
+        repr=False,
+    )
+
+    _error_callback: ErrorFuncT = field(
+        default=default_error_callback,
+        init=False,
+        repr=False,
+    )
+
+    def __post_init__(self, config: Config[InputT] | None) -> None:
+        configuration = config or Config()
+
+        # Configure logger
+        if configuration.logger:
+            self.logger = configuration.logger
+        else:
+            import logging
+
+            logging.basicConfig(
+                level=logging.DEBUG,
+                format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+            self.logger = logging.getLogger(__name__)
+
+        # Normalize base_dir
+        if isinstance(configuration.environment.base_dir, str):
+            configuration.environment.base_dir = Path(
+                configuration.environment.base_dir
+            )
+
+        # Extend sys.path for custom imports
+        if configuration.source_paths:
+            import sys
+
+            sys.path.extend(
+                [str(path.absolute()) for path in configuration.source_paths]
+            )
+            self.logger.debug(
+                f"Added [{len(configuration.source_paths)}] entries to PATH"
+            )
+
+        self.configuration = configuration
+
+    class Error(RuntimeError): ...
+
+    @property
+    def job_details(self) -> JobDetails:
+        if not self._job_details:
+            raise Algorithm.Error("JobDetails not initialized or missing")
+        return self._job_details
+
+    @property
+    def result(self) -> ResultT:
+        if self._result is None:
+            raise Algorithm.Error("Result missing, run the algorithm first")
+        return self._result
+
+    # ---------------------------
+    # Decorators (FastAPI-style)
+    # ---------------------------
+
+    def validate(self, fn: ValidateFuncT) -> ValidateFuncT:
+        self._validate_fn = fn
+        return fn
+
+    def run(self, fn: RunFuncT) -> RunFuncT:
+        self._run_fn = fn
+        return fn
+
+    def save_results(self, fn: SaveFuncT) -> SaveFuncT:
+        self._save_fn = fn
+        return fn
+
+    def on_error(self, fn: ErrorFuncT) -> ErrorFuncT:
+        self._error_callback = fn
+        return fn
+
+    # ---------------------------
+    # Execution Pipeline
+    # ---------------------------
+
+    def __call__(self) -> ResultT | None:
+        """Executes the algorithm pipeline: validate → run → save_results."""
+        # Load job details
+        self._job_details = JobDetails.load(
+            _type=self.configuration.custom_input,
+            base_dir=self.configuration.environment.base_dir,
+            dids=self.configuration.environment.dids,
+            transformation_did=self.configuration.environment.transformation_did,
+            secret=self.configuration.environment.secret,
+        )
+
+        self.logger.info("Loaded JobDetails")
+        self.logger.debug(asdict(self.job_details))
+
+        try:
+            # Validation step
+            self._validate_fn(self)
+
+            # Run step
+            if self._run_fn:
+                self.logger.info("Running algorithm...")
+                self._result = self._run_fn(self)
+            else:
+                self.logger.error("No run() function defined. Skipping execution.")
+                self._result = None
+
+            # Save step
+            self._save_fn(self, self._result, self.job_details.paths.outputs)
+
+        except Exception as e:
+            self._error_callback(self, e)
+
+        return self._result

{ocean_runner-0.2.12 → ocean_runner-0.2.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ocean-runner"
-version = "0.2.12"
+version = "0.2.19"
 description = "A fluent API for OceanProtocol algorithms"
 authors = [
     { name = "AgrospAI", email = "agrospai@udl.cat" },
@@ -15,7 +15,9 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 ]
 dependencies = [
-    "oceanprotocol-job-details>=0.2.7",
+    "oceanprotocol-job-details>=0.2.8",
+    "pydantic>=2.12.5",
+    "pydantic-settings>=2.12.0",
     "pytest>=8.4.2",
 ]
 
@@ -24,14 +26,24 @@ Homepage = "https://github.com/AgrospAI/ocean-runner"
 Issues = "https://github.com/AgrospAI/ocean-runner/issues"
 
 [tool.pytest.ini_options]
+log_level = "INFO"
+log_cli = true
 pythonpath = "ocean_runner"
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[dependency-groups]
+dev = [
+    "mypy>=1.19.1",
+]
+
 [tool.hatch.build.targets.sdist]
 include = ["ocean_runner"]
 
 [tool.hatch.build.targets.wheel]
 include = ["ocean_runner"]
+
+[tool.mypy]
+plugins = ['pydantic.mypy']

ocean_runner-0.2.12/ocean_runner/config.py

@@ -1,60 +0,0 @@
-import os
-from dataclasses import asdict, dataclass, field
-from logging import Logger
-from pathlib import Path
-from typing import Callable, Iterable, TypeVar
-
-T = TypeVar("T")
-
-DEFAULT = "DEFAULT"
-
-
-@dataclass
-class Environment:
-    """Environment variables mock"""
-
-    base_dir: str | None = field(
-        default_factory=lambda: os.environ.get("BASE_DIR", None),
-    )
-    """Base data directory, defaults to '/data'"""
-
-    dids: str = field(
-        default_factory=lambda: os.environ.get("DIDS", None),
-    )
-    """Datasets DID's, format: '["XXXX"]'"""
-
-    transformation_did: str = field(
-        default_factory=lambda: os.environ.get("TRANSFORMATION_DID", DEFAULT),
-    )
-    """Transformation (algorithm) DID"""
-
-    secret: str = field(
-        default_factory=lambda: os.environ.get("SECRET", DEFAULT),
-    )
-    """Super secret secret"""
-
-    dict = asdict
-
-
-@dataclass
-class Config:
-    """Algorithm overall configuration"""
-
-    custom_input: T | None = None
-    """Algorithm's custom input types, must be a dataclass_json"""
-
-    error_callback: Callable[[Exception], None] = None
-    """Callback to execute upon exceptions"""
-
-    logger: Logger | None = None
-    """Logger to use in the algorithm"""
-
-    source_paths: Iterable[Path] = field(
-        default_factory=lambda: [Path("/algorithm/src")]
-    )
-    """Paths that should be included so the code executes correctly"""
-
-    environment: Environment = field(
-        default_factory=lambda: Environment(),
-    )
-    """Mock of environment data"""

ocean_runner-0.2.12/ocean_runner/runner.py

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import InitVar, asdict, dataclass, field
-from logging import Logger
-from pathlib import Path
-from typing import Callable, Generic, Self, TypeVar
-
-from oceanprotocol_job_details import JobDetails
-
-from ocean_runner.config import Config
-
-JobDetailsT = TypeVar(
-    "JobDetailsT",
-)
-ResultT = TypeVar("ResultT")
-
-
-def default_error_callback(_: Algorithm, e: Exception) -> None:
-    raise e
-
-
-def default_validation(algorithm: Algorithm) -> None:
-    algorithm.logger.info("Validating input using default validation")
-
-    assert algorithm.job_details.ddos, "DDOs missing"
-    assert algorithm.job_details.files, "Files missing"
-
-
-def default_save(*, result: ResultT, base: Path, algorithm: Algorithm) -> None:
-    algorithm.logger.info("Saving results using default save")
-
-    with open(base / "result.txt", "w+") as f:
-        f.write(str(result))
-
-
-@dataclass
-class Algorithm(Generic[JobDetailsT, ResultT]):
-
-    config: InitVar[Config | None] = None
-
-    # Load from config
-    logger: Logger = field(init=False)
-
-    _job_details: JobDetails[JobDetailsT] = field(init=False)
-    _result: ResultT | None = field(default=None, init=False)
-
-    error_callback = default_error_callback
-
-    def __post_init__(self, config: Config | None) -> None:
-        config: Config = config or Config()
-
-        if config.error_callback:
-            self.error_callback = config.error_callback
-
-        if config.logger:
-            self.logger = config.logger
-        else:
-            import logging
-
-            logging.basicConfig(
-                level=logging.DEBUG,
-                format="%(asctime)s | %(levelname)-8s | %(name)s | %(message)s",
-                datefmt="%Y-%m-%d %H:%M:%S",
-            )
-
-            self.logger = logging.getLogger("ocean_runner")
-
-        if isinstance(config.environment.base_dir, str):
-            config.environment.base_dir = Path(config.environment.base_dir)
-
-        if config.source_paths:
-            import sys
-
-            sys.path.extend([str(path.absolute()) for path in config.source_paths])
-            self.logger.debug(f"Added [{len(config.source_paths)}] entries to PATH")
-
-        self._job_details = JobDetails.load(
-            _type=config.custom_input,
-            base_dir=config.environment.base_dir,
-            dids=config.environment.dids,
-            transformation_did=config.environment.transformation_did,
-            secret=config.environment.secret,
-        )
-
-        self.logger.info("Loaded JobDetails")
-        self.logger.debug(asdict(self.job_details))
-
-    class Error(RuntimeError): ...
-
-    @property
-    def job_details(self) -> JobDetails:
-        if not self._job_details:
-            raise Algorithm.Error("JobDetails not initialized or missing")
-        return self._job_details
-
-    @property
-    def result(self) -> ResultT:
-        if self._result is None:
-            raise Algorithm.Error("Result missing, run the algorithm first")
-        return self._result
-
-    def validate(
-        self,
-        callback: Callable[[Self], None] = default_validation,
-    ) -> Self:
-        self.logger.info("Validating instance...")
-        try:
-            callback(self)
-        except Exception as e:
-            self.error_callback(e)
-
-        return self
-
-    def run(
-        self,
-        callable: Callable[[Self], ResultT],
-    ) -> Self:
-        self.logger.info("Running algorithm...")
-        try:
-            self._result = callable(self)
-        except Exception as e:
-            self.error_callback(e)
-
-        return self
-
-    def save_results(
-        self,
-        callable: Callable[[ResultT, Path, Algorithm], None] = default_save,
-        *,
-        override_path: Path | None = None,
-    ) -> None:
-        self.logger.info("Saving results...")
-        try:
-            callable(
-                results=self.result,
-                base_path=override_path or self.job_details.paths.outputs,
-                algorithm=self,
-            )
-        except Exception as e:
-            self.error_callback(e)
-
-
-__all__ = [Algorithm]