port-ocean 0.22.12__tar.gz → 0.23.0__tar.gz

{port_ocean-0.22.12 → port_ocean-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.22.12
+Version: 0.23.0
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port

port_ocean-0.23.0/integrations/_infra/Dockerfile.local

@@ -0,0 +1,41 @@
+ARG BASE_PYTHON_IMAGE=debian:trixie-slim
+# debian:trixie-slim - Python 3.12
+FROM ${BASE_PYTHON_IMAGE}
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends librdkafka-dev python3 \
+    && apt-get clean
+RUN apt-get update \
+    && apt-get install -y \
+        --no-install-recommends \
+        wget \
+        g++ \
+        libssl-dev \
+        autoconf \
+        automake \
+        libtool \
+        curl \
+        librdkafka-dev \
+        python3 \
+        python3-pip \
+        python3-poetry \
+        build-essential\
+        git \
+        python3-venv \
+    && apt-get clean
+
+ARG BUILD_CONTEXT
+
+WORKDIR /app
+
+COPY . .
+RUN rm -rf .venv-docker ${BUILD_CONTEXT}/.venv-docker
+RUN python3 -m venv .venv-docker
+RUN python3 -m venv ${BUILD_CONTEXT}/.venv-docker
+
+
+WORKDIR /app/${BUILD_CONTEXT}
+
+WORKDIR /app
+
+ENTRYPOINT ["./integrations/_infra/entry_local.sh"]

port_ocean-0.23.0/integrations/_infra/entry_local.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+mkdir -p /tmp/prometheus_multiproc_dir
+export PROMETHEUS_MULTIPROC_DIR=/tmp/prometheus_multiproc_dir
+if [ -z "$BUILD_CONTEXT" ]; then
+    echo "BUILD_CONTEXT is not set"
+    exit 1
+fi
+
+if [ ! -d ".venv-docker" ]; then
+    /usr/bin/python3 -m venv .venv-docker
+    source .venv-docker/bin/activate
+    python -m pip install poetry
+    python -m poetry install
+fi
+
+cd $BUILD_CONTEXT
+
+if [ ! -d ".venv-docker" ]; then
+    /usr/bin/python3 -m venv .venv-docker
+    source .venv-docker/bin/activate
+    python -m pip install poetry
+    python -m poetry install
+fi
+source .venv-docker/bin/activate
+python -m pip install -e ../../
+
+ocean sail

{port_ocean-0.22.12 → port_ocean-0.23.0}/port_ocean/__init__.py

@@ -8,4 +8,9 @@ from .run import run  # noqa: E402
 from .version import __integration_version__, __version__  # noqa: E402
 
 
-__all__ = ["Ocean", "run", "__version__", "__integration_version__"]
+__all__ = [
+    "Ocean",
+    "run",
+    "__version__",
+    "__integration_version__",
+]

port_ocean-0.23.0/port_ocean/cache/base.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+
+from port_ocean.core.models import CachingStorageMode
+
+
+class CacheProvider(ABC):
+    """Base class for cache providers that defines the contract for all cache implementations."""
+
+    STORAGE_TYPE: CachingStorageMode
+
+    @abstractmethod
+    async def get(self, key: str) -> Optional[Any]:
+        """Get a value from the cache."""
+        pass
+
+    @abstractmethod
+    async def set(self, key: str, value: Any) -> None:
+        """Set a value in the cache."""
+        pass
+
+    @abstractmethod
+    async def clear(self) -> None:
+        """Clear all values from the cache."""
+        pass

port_ocean-0.23.0/port_ocean/cache/disk.py

@@ -0,0 +1,61 @@
+import pickle
+from pathlib import Path
+from typing import Any, Optional
+
+from port_ocean.cache.base import CacheProvider
+from port_ocean.cache.errors import FailedToReadCacheError, FailedToWriteCacheError
+from port_ocean.core.models import CachingStorageMode
+
+
+class FailedToReadCacheFileError(FailedToReadCacheError):
+    pass
+
+
+class FailedToWriteCacheFileError(FailedToWriteCacheError):
+    pass
+
+
+class DiskCacheProvider(CacheProvider):
+    STORAGE_TYPE = CachingStorageMode.disk
+
+    def __init__(self, cache_dir: str | None = None) -> None:
+        if cache_dir is None:
+            cache_dir = ".ocean_cache"
+        self._cache_dir = Path(cache_dir)
+        self._cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_cache_path(self, key: str) -> Path:
+        return self._cache_dir / f"{key}.pkl"
+
+    async def get(self, key: str) -> Optional[Any]:
+        cache_path = self._get_cache_path(key)
+        if not cache_path.exists():
+            return None
+
+        try:
+            with open(cache_path, "rb") as f:
+                return pickle.load(f)
+        except (pickle.PickleError, EOFError) as e:
+            raise FailedToReadCacheFileError(
+                f"Failed to read cache file: {cache_path}: {str(e)}"
+            )
+
+    async def set(self, key: str, value: Any) -> None:
+        cache_path = self._get_cache_path(key)
+        try:
+            with open(cache_path, "wb") as f:
+                pickle.dump(value, f)
+        except (pickle.PickleError, IOError) as e:
+            raise FailedToWriteCacheFileError(
+                f"Failed to write cache file: {cache_path}: {str(e)}"
+            )
+
+    async def clear(self) -> None:
+        try:
+            for cache_file in self._cache_dir.glob("*.pkl"):
+                try:
+                    cache_file.unlink()
+                except OSError:
+                    pass
+        except OSError:
+            pass

port_ocean-0.23.0/port_ocean/cache/errors.py

@@ -0,0 +1,10 @@
+class CacheError(Exception):
+    pass
+
+
+class FailedToReadCacheError(CacheError):
+    pass
+
+
+class FailedToWriteCacheError(CacheError):
+    pass

port_ocean-0.23.0/port_ocean/cache/memory.py

@@ -0,0 +1,36 @@
+from typing import Any, Optional
+from port_ocean.cache.base import CacheProvider
+from port_ocean.cache.errors import FailedToReadCacheError, FailedToWriteCacheError
+from port_ocean.core.models import CachingStorageMode
+
+
+class FailedToReadCacheMemoryError(FailedToReadCacheError):
+    pass
+
+
+class FailedToWriteCacheMemoryError(FailedToWriteCacheError):
+    pass
+
+
+class InMemoryCacheProvider(CacheProvider):
+    CACHE_KEY = "cache"
+    STORAGE_TYPE = CachingStorageMode.memory
+
+    def __init__(self, caching_storage: dict[str, Any] | None = None) -> None:
+        self._storage = caching_storage or {}
+        self._storage[self.CACHE_KEY] = self._storage.get(self.CACHE_KEY, {})
+
+    async def get(self, key: str) -> Optional[Any]:
+        try:
+            return self._storage.get(self.CACHE_KEY, {}).get(key)
+        except KeyError as e:
+            raise FailedToReadCacheMemoryError(f"Failed to read cache: {str(e)}")
+
+    async def set(self, key: str, value: Any) -> None:
+        try:
+            self._storage[self.CACHE_KEY][key] = value
+        except KeyError as e:
+            raise FailedToWriteCacheMemoryError(f"Failed to write cache: {str(e)}")
+
+    async def clear(self) -> None:
+        self._storage[self.CACHE_KEY].clear()

{port_ocean-0.22.12 → port_ocean-0.23.0}/port_ocean/config/settings.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Type, cast
+from typing import Any, Literal, Optional, Type, cast
 
 from pydantic import AnyHttpUrl, Extra, parse_obj_as, parse_raw_as
 from pydantic.class_validators import root_validator, validator
@@ -8,7 +8,12 @@ from pydantic.main import BaseModel
 
 from port_ocean.config.base import BaseOceanModel, BaseOceanSettings
 from port_ocean.core.event_listener import EventListenerSettingsType
-from port_ocean.core.models import CreatePortResourcesOrigin, Runtime
+from port_ocean.core.models import (
+    CachingStorageMode,
+    CreatePortResourcesOrigin,
+    Runtime,
+    ProcessExecutionMode,
+)
 from port_ocean.utils.misc import get_integration_name, get_spec_file
 
 LogLevelType = Literal["ERROR", "WARNING", "INFO", "DEBUG", "CRITICAL"]
@@ -93,6 +98,8 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     )
     max_event_processing_seconds: float = 90.0
     max_wait_seconds_before_shutdown: float = 5.0
+    caching_storage_mode: Optional[CachingStorageMode] = Field(default=None)
+    process_execution_mode: Optional[ProcessExecutionMode] = Field(default=None)
 
     @validator("metrics", pre=True)
     def validate_metrics(cls, v: Any) -> MetricsSettings | dict[str, Any] | None:

{port_ocean-0.22.12 → port_ocean-0.23.0}/port_ocean/core/integrations/mixins/sync_raw.py

@@ -1,12 +1,12 @@
 import asyncio
+import uuid
 from graphlib import CycleError
 import inspect
 import typing
 from typing import Callable, Awaitable, Any
-
+import multiprocessing
 import httpx
 from loguru import logger
-
 from port_ocean.clients.port.types import UserAgentType
 from port_ocean.context.event import TriggerType, event_context, EventType, event
 from port_ocean.context.ocean import ocean
@@ -20,7 +20,7 @@ from port_ocean.core.integrations.mixins.utils import (
     resync_generator_wrapper,
     resync_function_wrapper,
 )
-from port_ocean.core.models import Entity
+from port_ocean.core.models import Entity, ProcessExecutionMode
 from port_ocean.core.ocean_types import (
     RAW_RESULT,
     RESYNC_RESULT,
@@ -33,6 +33,7 @@ from port_ocean.core.utils.utils import resolve_entities_diff, zip_and_sum, gath
 from port_ocean.exceptions.core import OceanAbortException
 from port_ocean.helpers.metric.metric import SyncState, MetricType, MetricPhase
 from port_ocean.helpers.metric.utils import TimeMetric
+from port_ocean.utils.ipc import FileIPC
 
 SEND_RAW_DATA_EXAMPLES_AMOUNT = 5
 
@@ -267,7 +268,6 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                     objects_diff[0].entity_selector_diff.passed, user_agent_type
                     )
 
-
         return CalculationResult(
             number_of_transformed_entities=len(objects_diff[0].entity_selector_diff.passed),
             entity_selector_diff=objects_diff[0].entity_selector_diff._replace(passed=modified_objects),
@@ -344,8 +344,8 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         user_agent_type,
                         send_raw_data_examples_amount=send_raw_data_examples_amount
                     )
-                    errors.extend(calculation_result.errors)
                     passed_entities.extend(calculation_result.entity_selector_diff.passed)
+                    errors.extend(calculation_result.errors)
                     number_of_transformed_entities += calculation_result.number_of_transformed_entities
             except* OceanAbortException as error:
                 ocean.metrics.sync_state = SyncState.FAILED
@@ -355,6 +355,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             f"Finished registering kind: {resource_config.kind}-{resource.resource.index} ,{len(passed_entities)} entities out of {number_of_raw_results} raw results"
         )
 
+
         ocean.metrics.set_metric(
             name=MetricType.SUCCESS_NAME,
             labels=[ocean.metrics.current_resource_kind(), MetricPhase.RESYNC],
@@ -584,6 +585,72 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 for entity in event.entity_topological_sorter.get_entities(False):
                     await self.entities_state_applier.context.port_client.upsert_entity(entity,event.port_app_config.get_port_request_options(),user_agent_type,should_raise=False)
 
+    def process_resource_in_subprocess(self,
+        file_ipc_map: dict[str, FileIPC],
+        resource: ResourceConfig,
+        index: int,
+        user_agent_type: UserAgentType,
+    ) -> None:
+        logger.info(f"process started successfully for {resource.kind} with index {index}")
+
+        async def process_resource_task() -> None:
+            result = await self._process_resource(
+                resource, index, user_agent_type
+            )
+            file_ipc_map["process_resource"].save(result)
+            file_ipc_map["topological_entities"].save(
+                event.entity_topological_sorter.entities
+            )
+
+        asyncio.run(process_resource_task())
+        logger.info(f"Process finished for {resource.kind} with index {index}")
+
+    async def process_resource(self, resource: ResourceConfig, index: int, user_agent_type: UserAgentType) -> tuple[list[Entity], list[Exception]]:
+            if ocean.app.process_execution_mode == ProcessExecutionMode.multi_process:
+                id = uuid.uuid4()
+                logger.info(f"Starting subprocess with id {id}")
+                file_ipc_map = {
+                    "process_resource": FileIPC(id, "process_resource",([],[])),
+                    "topological_entities": FileIPC(id, "topological_entities",[]),
+                }
+                process = multiprocessing.Process(target=self.process_resource_in_subprocess, args=(file_ipc_map,resource,index,user_agent_type))
+                process.start()
+                process.join()
+                if process.exitcode != 0:
+                    logger.error(f"Process {id} failed with exit code {process.exitcode}")
+                event.entity_topological_sorter.entities.extend(file_ipc_map["topological_entities"].load())
+                return file_ipc_map["process_resource"].load()
+
+            else:
+                return await self._process_resource(resource,index,user_agent_type)
+
+    async def _process_resource(self,resource: ResourceConfig, index: int, user_agent_type: UserAgentType)-> tuple[list[Entity], list[Exception]]:
+        # create resource context per resource kind, so resync method could have access to the resource
+        # config as we might have multiple resources in the same event
+        async with resource_context(resource,index):
+            resource_kind_id = f"{resource.kind}-{index}"
+            ocean.metrics.sync_state = SyncState.SYNCING
+            task = asyncio.create_task(
+                self._register_in_batches(resource, user_agent_type)
+            )
+            event.on_abort(lambda: task.cancel())
+            kind_results: tuple[list[Entity], list[Exception]] = await task
+            ocean.metrics.set_metric(
+                name=MetricType.OBJECT_COUNT_NAME,
+                labels=[ocean.metrics.current_resource_kind(), MetricPhase.LOAD, MetricPhase.LoadResult.LOADED],
+                value=len(kind_results[0])
+            )
+
+            if ocean.metrics.sync_state != SyncState.FAILED:
+                ocean.metrics.sync_state = SyncState.COMPLETED
+
+            await ocean.metrics.send_metrics_to_webhook(
+                kind=resource_kind_id
+            )
+            # await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id) # TODO: uncomment this when end points are ready
+
+            return kind_results
+
     @TimeMetric(MetricPhase.RESYNC)
     async def sync_raw_all(
         self,
@@ -622,6 +689,9 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             ocean.metrics.initialize_metrics(kinds)
             # await ocean.metrics.report_sync_metrics(kinds=kinds) # TODO: uncomment this when end points are ready
 
+            # Clear cache
+            await ocean.app.cache_provider.clear()
+
             # Execute resync_start hooks
             for resync_start_fn in self.event_strategy["resync_start"]:
                 await resync_start_fn()
@@ -640,32 +710,13 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
             creation_results: list[tuple[list[Entity], list[Exception]]] = []
 
-
+            multiprocessing.set_start_method('fork', True)
             try:
                 for index,resource in enumerate(app_config.resources):
-                    # create resource context per resource kind, so resync method could have access to the resource
-                    # config as we might have multiple resources in the same event
-                    async with resource_context(resource,index):
-                        resource_kind_id = f"{resource.kind}-{index}"
-                        ocean.metrics.sync_state = SyncState.SYNCING
-                        # await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id) # TODO: uncomment this when end points are ready
-
-                        task = asyncio.create_task(
-                            self._register_in_batches(resource, user_agent_type)
-                        )
 
-                        event.on_abort(lambda: task.cancel())
-                        kind_results: tuple[list[Entity], list[Exception]] = await task
+                    logger.info(f"Starting processing resource {resource.kind} with index {index}")
 
-                        creation_results.append(kind_results)
-
-                        if ocean.metrics.sync_state != SyncState.FAILED:
-                            ocean.metrics.sync_state = SyncState.COMPLETED
-
-                        await ocean.metrics.send_metrics_to_webhook(
-                            kind=resource_kind_id
-                        )
-                        # await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id) # TODO: uncomment this when end points are ready
+                    creation_results.append(await self.process_resource(resource,index,user_agent_type))
 
                 await self.sort_and_upsert_failed_entities(user_agent_type)
 
@@ -721,3 +772,5 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         logger.info("Finished executing resync_complete hooks")
 
                     return True
+            finally:
+                await ocean.app.cache_provider.clear()

{port_ocean-0.22.12 → port_ocean-0.23.0}/port_ocean/core/models.py

@@ -11,6 +11,16 @@ class CreatePortResourcesOrigin(StrEnum):
     Port = "Port"
 
 
+class ProcessExecutionMode(StrEnum):
+    multi_process = "multi_process"
+    single_process = "single_process"
+
+
+class CachingStorageMode(StrEnum):
+    disk = "disk"
+    memory = "memory"
+
+
 class Runtime(Enum):
     Saas = "Saas"
     OnPrem = "OnPrem"

{port_ocean-0.22.12 → port_ocean-0.23.0}/port_ocean/helpers/metric/metric.py

@@ -10,6 +10,7 @@ from prometheus_client import Gauge
 import prometheus_client.openmetrics
 import prometheus_client.openmetrics.exposition
 import prometheus_client.parser
+from prometheus_client import multiprocess
 
 if TYPE_CHECKING:
     from port_ocean.config.settings import MetricsSettings, IntegrationSettings
@@ -108,11 +109,14 @@ class Metrics:
         metrics_settings: "MetricsSettings",
         integration_configuration: "IntegrationSettings",
         port_client: "PortClient",
+        multiprocessing_enabled: bool = False,
     ) -> None:
         self.metrics_settings = metrics_settings
         self.integration_configuration = integration_configuration
         self.port_client = port_client
         self.registry = prometheus_client.CollectorRegistry()
+        if multiprocessing_enabled:
+            multiprocess.MultiProcessCollector(self.registry)
         self.metrics: dict[str, Gauge] = {}
         self.load_metrics()
         self._integration_version: Optional[str] = None

{port_ocean-0.22.12 → port_ocean-0.23.0}/port_ocean/ocean.py

@@ -4,6 +4,10 @@ from contextlib import asynccontextmanager
 import threading
 from typing import Any, AsyncIterator, Callable, Dict, Type
 
+from port_ocean.cache.base import CacheProvider
+from port_ocean.cache.disk import DiskCacheProvider
+from port_ocean.cache.memory import InMemoryCacheProvider
+from port_ocean.core.models import ProcessExecutionMode
 import port_ocean.helpers.metric.metric
 
 from fastapi import FastAPI, APIRouter
@@ -66,11 +70,16 @@ class Ocean:
             integration_type=self.config.integration.type,
             integration_version=__integration_version__,
         )
-
+        self.cache_provider: CacheProvider = self._get_caching_provider()
+        self.process_execution_mode: ProcessExecutionMode = (
+            self._get_process_execution_mode()
+        )
         self.metrics = port_ocean.helpers.metric.metric.Metrics(
             metrics_settings=self.config.metrics,
             integration_configuration=self.config.integration,
             port_client=self.port_client,
+            multiprocessing_enabled=self.process_execution_mode
+            == ProcessExecutionMode.multi_process,
         )
 
         self.webhook_manager = LiveEventsProcessorManager(
@@ -90,6 +99,24 @@ class Ocean:
 
         self.app_initialized = False
 
+    def _get_process_execution_mode(self) -> ProcessExecutionMode:
+        if self.config.process_execution_mode:
+            return self.config.process_execution_mode
+        return ProcessExecutionMode.single_process
+
+    def _get_caching_provider(self) -> CacheProvider:
+        if self.config.caching_storage_mode:
+            caching_type_to_provider = {
+                DiskCacheProvider.STORAGE_TYPE: DiskCacheProvider,
+                InMemoryCacheProvider.STORAGE_TYPE: InMemoryCacheProvider,
+            }
+            if self.config.caching_storage_mode in caching_type_to_provider:
+                return caching_type_to_provider[self.config.caching_storage_mode]()
+
+        if self.config.process_execution_mode == ProcessExecutionMode.multi_process:
+            return DiskCacheProvider()
+        return InMemoryCacheProvider()
+
     def is_saas(self) -> bool:
         return self.config.runtime.is_saas_runtime
 

{port_ocean-0.22.12 → port_ocean-0.23.0}/port_ocean/run.py

@@ -21,7 +21,6 @@ def _get_default_config_factory() -> None | Type[BaseModel]:
     config_factory = None
     if spec is not None:
         config_factory = default_config_factory(spec.get("configurations", []))
-
     return config_factory
 
 

port_ocean-0.23.0/port_ocean/tests/cache/__init__.py

@@ -0,0 +1 @@
+"""Tests for cache providers."""

port_ocean-0.23.0/port_ocean/tests/cache/test_disk_cache.py

@@ -0,0 +1,92 @@
+import os
+import pytest
+from pathlib import Path
+
+from port_ocean.cache.disk import (
+    DiskCacheProvider,
+    FailedToReadCacheFileError,
+    FailedToWriteCacheFileError,
+)
+
+
+@pytest.fixture
+def disk_cache(tmp_path: Path) -> DiskCacheProvider:
+    """Fixture that provides a DiskCacheProvider with a temporary directory."""
+    return DiskCacheProvider(cache_dir=str(tmp_path))
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_set_get(disk_cache: DiskCacheProvider) -> None:
+    """Test setting and getting values from disk cache."""
+    # Test basic set/get
+    await disk_cache.set("test_key", "test_value")
+    assert await disk_cache.get("test_key") == "test_value"
+
+    # Test with different types
+    test_data = {
+        "string": "hello",
+        "int": 42,
+        "float": 3.14,
+        "list": [1, 2, 3],
+        "dict": {"a": 1, "b": 2},
+    }
+
+    for key, value in test_data.items():
+        await disk_cache.set(key, value)
+        assert await disk_cache.get(key) == value
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_clear(disk_cache: DiskCacheProvider) -> None:
+    """Test clearing all values from disk cache."""
+    # Add multiple values
+    for i in range(5):
+        await disk_cache.set(f"key_{i}", f"value_{i}")
+
+    # Verify values exist
+    for i in range(5):
+        assert await disk_cache.get(f"key_{i}") == f"value_{i}"
+
+    # Clear cache
+    await disk_cache.clear()
+
+    # Verify all values are gone
+    for i in range(5):
+        assert await disk_cache.get(f"key_{i}") is None
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_nonexistent_key(disk_cache: DiskCacheProvider) -> None:
+    """Test getting a nonexistent key from disk cache."""
+    assert await disk_cache.get("nonexistent_key") is None
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_corrupted_file(
+    disk_cache: DiskCacheProvider, tmp_path: Path
+) -> None:
+    """Test handling of corrupted cache files."""
+    # Create a corrupted pickle file
+    cache_path = tmp_path / "test_key.pkl"
+    with open(cache_path, "wb") as f:
+        f.write(b"invalid pickle data")
+
+    # Attempting to read should raise FailedToReadCacheFileError
+    with pytest.raises(FailedToReadCacheFileError):
+        await disk_cache.get("test_key")
+
+
+@pytest.mark.asyncio
+async def test_disk_cache_write_error(
+    disk_cache: DiskCacheProvider, tmp_path: Path
+) -> None:
+    """Test handling of write errors."""
+    # Make the cache directory read-only
+    os.chmod(tmp_path, 0o444)
+
+    # Attempting to write should raise FailedToWriteCacheFileError
+    with pytest.raises(FailedToWriteCacheFileError):
+        await disk_cache.set("test_key", "test_value")
+
+    # Restore permissions
+    os.chmod(tmp_path, 0o755)