pipefunc 0.1.0__tar.gz

pipefunc-0.1.0/AUTHORS.md

@@ -0,0 +1,2 @@
+# The authors of `pipefunc` are:
+- [Bas Nijholt](http://nijho.lt) ([@basnijholt](https://github.com/basnijholt))

pipefunc-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023, Bas Nijholt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pipefunc-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include pipefunc *.py
+include LICENSE
+include README.md

pipefunc-0.1.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.1
+Name: pipefunc
+Version: 0.1.0
+Summary: A Python library for defining, managing, and executing function pipelines.
+Maintainer-email: Bas Nijholt <bas@nijho.lt>
+License: MIT
+Project-URL: homepage, https://pipefunc.readthedocs.io/
+Project-URL: documentation, https://pipefunc.readthedocs.io/
+Project-URL: repository, https://github.com/basnijholt/pipefunc
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: plotting
+Provides-Extra: test
+Provides-Extra: docs
+Provides-Extra: dev
+License-File: LICENSE
+License-File: AUTHORS.md
+
+# pipefunc: function composition magic for Python
+
+> Lightweight function pipeline creation: 📚 Less Bookkeeping, 🎯 More Doing
+
+![](https://user-images.githubusercontent.com/6897215/253785642-cf2a6941-2ea6-41b0-8225-b3e52e94c4de.png)
+
+<!-- toc-start -->
+## :books: Table of Contents
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+- [:thinking: What is this?](#thinking-what-is-this)
+- [:rocket: Key Features](#rocket-key-features)
+- [:test_tube: How does it work?](#test_tube-how-does-it-work)
+- [:notebook: Jupyter Notebook Example](#notebook-jupyter-notebook-example)
+- [:computer: Installation](#computer-installation)
+- [:hammer_and_wrench: Development](#hammer_and_wrench-development)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+<!-- toc-end -->
+
+## :thinking: What is this?
+
+`pipefunc` is a Python library designed to create and manage complex networks of interdependent functions, often known as function pipelines.
+
+In a function pipeline, each function can have dependencies on the results of other functions. Managing these dependencies, ensuring each function has the inputs it needs, and determining the order of execution can become an annoying bookkeeping task in complex cases.
+
+`pipefunc` simplifies this process by allowing you to declare the dependencies of each function and automatically organizing the execution order to satisfy these dependencies. Additionally, the library provides features for visualizing the function pipeline, simplifying the pipeline graph, caching function results for efficiency, and profiling resource usage for optimization.
+
+For example, imagine you have a set of functions where `function B` needs the output from `function A`, and `function C` needs the outputs from both `function A` and `function B`. `pipefunc` allows you to specify these dependencies when you create the functions and then automatically manages their execution. It also provides tools for visualizing this function network, simplifying it if possible, and understanding the resource usage of each function.
+
+The library is designed to be an efficient and flexible tool for managing complex function dependencies in an intuitive and clear way. Whether you're dealing with data processing tasks, scientific computations, machine learning (AI) workflows, or other scenarios where functions depend on one another, `pipefunc` can help streamline your code and improve your productivity.
+
+## :rocket: Key Features
+
+Some of the key features of `pipefunc` include:
+
+1. 🚀 **Function Composition and Pipelining:** The core functionality of `pipefunc` is to create a pipeline of functions, allowing you to feed the output of one function into another, and execute them in the right order.
+1. 📊 **Visualizing Pipelines:** `pipefunc` can generate a visual graph of the function pipeline, making it easier to understand the flow of data.
+1. 💡 **Flexible Function Arguments:** `pipefunc` lets you call a function with different combinations of arguments, automatically determining which other functions to call based on the arguments you provide.
+1. 👥 **Multiple Outputs:** `pipefunc` supports functions that return multiple results, allowing each result to be used as input to other functions.
+1. ➡️ **Reducing Pipelines:** `pipefunc` can simplify a complex pipeline by merging nodes, improving computational efficiency at the cost of losing visibility into some intermediate steps.
+1. 🎛️ **Resources Report:** `pipefunc` provides a report on the performance of your pipeline, including CPU usage, memory usage, and execution time, helping you identify bottlenecks and optimize your code.
+1. 🔄 **Parallel Execution and Caching:** `pipefunc` supports parallel execution of functions, and caching of results to avoid redundant computation.
+1. 🔍 **Parameter Sweeps:** `pipefunc` provides a utility for generating combinations of parameters to use in a parameter sweep, along with the ability to cache results to optimize the sweep.
+1. 🛠️ **Flexibility and Ease of Use:** `pipefunc` is a lightweight, flexible, and powerful tool for managing complex function dependencies in a clear and intuitive way, designed to improve your productivity in any scenario where functions depend on one another.
+
+
+## :test_tube: How does it work?
+
+pipefunc provides a Pipeline class that you use to define your function pipeline.
+You add functions to the pipeline using the `pipefunc` decorator, which also lets you specify a function's output name and dependencies.
+Once your pipeline is defined, you can execute it for specific output values, simplify it by combining functions with the same root arguments, visualize it as a directed graph, and profile the resource usage of the pipeline functions.
+For more detailed usage instructions and examples, please check the usage example provided in the package.
+
+Here is a simple example usage of pipefunc to illustrate its primary features:
+
+```python
+from pipefunc import pipefunc, Pipeline
+
+# Define three functions that will be a part of the pipeline
+@pipefunc(output_name="c")
+def f_c(a, b):
+    return a + b
+
+@pipefunc(output_name="d")
+def f_d(b, c):
+    return b * c
+
+@pipefunc(output_name="e")
+def f_e(c, d, x=1):
+    return c * d * x
+
+# Create a pipeline with these functions
+funcs = [f_c, f_d, f_e]
+pipeline = Pipeline(funcs, profile=True)
+
+# You can access and call these functions using the func method
+h_d = pipeline.func("d")
+assert h_d(a=2, b=3) == 15
+
+h_e = pipeline.func("e")
+assert h_e(a=2, b=3, x=1) == 75
+assert h_e(c=5, d=15, x=1) == 75
+
+# Visualize the pipeline
+pipeline.visualize()
+
+# Get all possible argument mappings for each function
+all_args = pipeline.all_arg_combinations()
+print(all_args)
+
+# Show resource reporting (only works if profile=True)
+pipeline.resources_report()
+```
+
+This example demonstrates defining a pipeline with `f_c`, `f_d`, `f_e` functions, accessing and executing these functions using the pipeline, visualizing the pipeline graph, getting all possible argument mappings, and reporting on the resource usage.
+This basic example should give you an idea of how to use pipefunc to construct and manage function pipelines.
+
+## :notebook: Jupyter Notebook Example
+
+See the detailed usage example and more in our [example.ipynb](https://github.com/basnijholt/pipefunc/blob/main/example.ipynb).
+
+## :computer: Installation
+
+Install the **latest stable** version from conda (recommended):
+
+```bash
+conda install "pipefunc[plotting]"
+```
+
+or from PyPI:
+
+```bash
+pip install pipefunc
+```
+
+or install **main** with:
+
+```bash
+pip install -U https://github.com/basnijholt/pipefunc/archive/main.zip
+```
+
+or clone the repository and do a dev install (recommended for dev):
+
+```bash
+git clone git@github.com:basnijholt/pipefunc.git
+cd pipefunc
+pip install -e ".[dev,test,plotting]"
+```
+
+## :hammer_and_wrench: Development
+
+We use [`pre-commit`](https://pre-commit.com/) to manage pre-commit hooks, which helps us ensure that our code is always clean and compliant with our coding standards.
+To set it up, install pre-commit with pip and then run the install command:
+
+```bash
+pip install pre-commit
+pre-commit install
+```

pipefunc-0.1.0/README.md

@@ -0,0 +1,140 @@
+# pipefunc: function composition magic for Python
+
+> Lightweight function pipeline creation: 📚 Less Bookkeeping, 🎯 More Doing
+
+![](https://user-images.githubusercontent.com/6897215/253785642-cf2a6941-2ea6-41b0-8225-b3e52e94c4de.png)
+
+<!-- toc-start -->
+## :books: Table of Contents
+<!-- START doctoc generated TOC please keep comment here to allow auto update -->
+<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
+
+- [:thinking: What is this?](#thinking-what-is-this)
+- [:rocket: Key Features](#rocket-key-features)
+- [:test_tube: How does it work?](#test_tube-how-does-it-work)
+- [:notebook: Jupyter Notebook Example](#notebook-jupyter-notebook-example)
+- [:computer: Installation](#computer-installation)
+- [:hammer_and_wrench: Development](#hammer_and_wrench-development)
+
+<!-- END doctoc generated TOC please keep comment here to allow auto update -->
+<!-- toc-end -->
+
+## :thinking: What is this?
+
+`pipefunc` is a Python library designed to create and manage complex networks of interdependent functions, often known as function pipelines.
+
+In a function pipeline, each function can have dependencies on the results of other functions. Managing these dependencies, ensuring each function has the inputs it needs, and determining the order of execution can become an annoying bookkeeping task in complex cases.
+
+`pipefunc` simplifies this process by allowing you to declare the dependencies of each function and automatically organizing the execution order to satisfy these dependencies. Additionally, the library provides features for visualizing the function pipeline, simplifying the pipeline graph, caching function results for efficiency, and profiling resource usage for optimization.
+
+For example, imagine you have a set of functions where `function B` needs the output from `function A`, and `function C` needs the outputs from both `function A` and `function B`. `pipefunc` allows you to specify these dependencies when you create the functions and then automatically manages their execution. It also provides tools for visualizing this function network, simplifying it if possible, and understanding the resource usage of each function.
+
+The library is designed to be an efficient and flexible tool for managing complex function dependencies in an intuitive and clear way. Whether you're dealing with data processing tasks, scientific computations, machine learning (AI) workflows, or other scenarios where functions depend on one another, `pipefunc` can help streamline your code and improve your productivity.
+
+## :rocket: Key Features
+
+Some of the key features of `pipefunc` include:
+
+1. 🚀 **Function Composition and Pipelining:** The core functionality of `pipefunc` is to create a pipeline of functions, allowing you to feed the output of one function into another, and execute them in the right order.
+1. 📊 **Visualizing Pipelines:** `pipefunc` can generate a visual graph of the function pipeline, making it easier to understand the flow of data.
+1. 💡 **Flexible Function Arguments:** `pipefunc` lets you call a function with different combinations of arguments, automatically determining which other functions to call based on the arguments you provide.
+1. 👥 **Multiple Outputs:** `pipefunc` supports functions that return multiple results, allowing each result to be used as input to other functions.
+1. ➡️ **Reducing Pipelines:** `pipefunc` can simplify a complex pipeline by merging nodes, improving computational efficiency at the cost of losing visibility into some intermediate steps.
+1. 🎛️ **Resources Report:** `pipefunc` provides a report on the performance of your pipeline, including CPU usage, memory usage, and execution time, helping you identify bottlenecks and optimize your code.
+1. 🔄 **Parallel Execution and Caching:** `pipefunc` supports parallel execution of functions, and caching of results to avoid redundant computation.
+1. 🔍 **Parameter Sweeps:** `pipefunc` provides a utility for generating combinations of parameters to use in a parameter sweep, along with the ability to cache results to optimize the sweep.
+1. 🛠️ **Flexibility and Ease of Use:** `pipefunc` is a lightweight, flexible, and powerful tool for managing complex function dependencies in a clear and intuitive way, designed to improve your productivity in any scenario where functions depend on one another.
+
+
+## :test_tube: How does it work?
+
+pipefunc provides a Pipeline class that you use to define your function pipeline.
+You add functions to the pipeline using the `pipefunc` decorator, which also lets you specify a function's output name and dependencies.
+Once your pipeline is defined, you can execute it for specific output values, simplify it by combining functions with the same root arguments, visualize it as a directed graph, and profile the resource usage of the pipeline functions.
+For more detailed usage instructions and examples, please check the usage example provided in the package.
+
+Here is a simple example usage of pipefunc to illustrate its primary features:
+
+```python
+from pipefunc import pipefunc, Pipeline
+
+# Define three functions that will be a part of the pipeline
+@pipefunc(output_name="c")
+def f_c(a, b):
+    return a + b
+
+@pipefunc(output_name="d")
+def f_d(b, c):
+    return b * c
+
+@pipefunc(output_name="e")
+def f_e(c, d, x=1):
+    return c * d * x
+
+# Create a pipeline with these functions
+funcs = [f_c, f_d, f_e]
+pipeline = Pipeline(funcs, profile=True)
+
+# You can access and call these functions using the func method
+h_d = pipeline.func("d")
+assert h_d(a=2, b=3) == 15
+
+h_e = pipeline.func("e")
+assert h_e(a=2, b=3, x=1) == 75
+assert h_e(c=5, d=15, x=1) == 75
+
+# Visualize the pipeline
+pipeline.visualize()
+
+# Get all possible argument mappings for each function
+all_args = pipeline.all_arg_combinations()
+print(all_args)
+
+# Show resource reporting (only works if profile=True)
+pipeline.resources_report()
+```
+
+This example demonstrates defining a pipeline with `f_c`, `f_d`, `f_e` functions, accessing and executing these functions using the pipeline, visualizing the pipeline graph, getting all possible argument mappings, and reporting on the resource usage.
+This basic example should give you an idea of how to use pipefunc to construct and manage function pipelines.
+
+## :notebook: Jupyter Notebook Example
+
+See the detailed usage example and more in our [example.ipynb](https://github.com/basnijholt/pipefunc/blob/main/example.ipynb).
+
+## :computer: Installation
+
+Install the **latest stable** version from conda (recommended):
+
+```bash
+conda install "pipefunc[plotting]"
+```
+
+or from PyPI:
+
+```bash
+pip install pipefunc
+```
+
+or install **main** with:
+
+```bash
+pip install -U https://github.com/basnijholt/pipefunc/archive/main.zip
+```
+
+or clone the repository and do a dev install (recommended for dev):
+
+```bash
+git clone git@github.com:basnijholt/pipefunc.git
+cd pipefunc
+pip install -e ".[dev,test,plotting]"
+```
+
+## :hammer_and_wrench: Development
+
+We use [`pre-commit`](https://pre-commit.com/) to manage pre-commit hooks, which helps us ensure that our code is always clean and compliant with our coding standards.
+To set it up, install pre-commit with pip and then run the install command:
+
+```bash
+pip install pre-commit
+pre-commit install
+```

pipefunc-0.1.0/pipefunc/__init__.py

@@ -0,0 +1,25 @@
+"""PipeFunc: A Python library for defining, managing, and executing function pipelines."""
+
+from pipefunc._pipefunc import Pipeline, PipelineFunction, pipefunc
+from pipefunc._sweep import (
+    MultiSweep,
+    Sweep,
+    count_sweep,
+    generate_sweep,
+    get_precalculation_order,
+    set_cache_for_sweep,
+)
+from pipefunc._version import __version__
+
+__all__ = [
+    "__version__",
+    "count_sweep",
+    "generate_sweep",
+    "get_precalculation_order",
+    "pipefunc",
+    "Pipeline",
+    "PipelineFunction",
+    "set_cache_for_sweep",
+    "Sweep",
+    "MultiSweep",
+]

pipefunc-0.1.0/pipefunc/_cache.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+from contextlib import nullcontext
+from multiprocessing import Manager
+from typing import TYPE_CHECKING, Any
+
+import cloudpickle
+
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+    from multiprocessing.managers import ListProxy
+
+_NONE_RETURN_STR = "__ReturnsNone__"
+
+
+class HybridCache:
+    """A hybrid cache implementation.
+
+    This uses a combination of Least Frequently Used (LFU) and
+    Least Computationally Expensive (LCE) strategies for invalidating cache entries.
+
+    The cache invalidation strategy calculates a score for each entry based on its
+    access frequency and computation duration. The entry with the lowest score will
+    be invalidated when the cache reaches its maximum size.
+
+    Attributes
+    ----------
+    max_size
+        The maximum number of entries the cache can store.
+    access_weight
+        The weight given to the access frequency in the score calculation.
+    duration_weight
+        The weight given to the computation duration in the score calculation.
+    """
+
+    def __init__(
+        self,
+        max_size: int = 128,
+        access_weight: float = 0.5,
+        duration_weight: float = 0.5,
+        *,
+        shared: bool = True,
+    ) -> None:
+        """Initialize the HybridCache instance."""
+        if shared:
+            manager = Manager()
+            self._cache = manager.dict()
+            self._access_counts = manager.dict()
+            self._computation_durations = manager.dict()
+            self.lock = manager.Lock()
+        else:
+            self._cache = {}  # type: ignore[assignment]
+            self._access_counts = {}  # type: ignore[assignment]
+            self._computation_durations = {}  # type: ignore[assignment]
+            self.lock = nullcontext()  # type: ignore[assignment]
+        self.max_size: int = max_size
+        self.access_weight: float = access_weight
+        self.duration_weight: float = duration_weight
+        self.shared: bool = shared
+
+    @property
+    def cache(self) -> dict[Hashable, Any]:
+        """Return the cache entries."""
+        if not self.shared:
+            assert isinstance(self._cache, dict)
+            return self._cache
+        with self.lock:
+            return dict(self._cache.items())
+
+    @property
+    def access_counts(self) -> dict[Hashable, int]:
+        """Return the access counts of the cache entries."""
+        if not self.shared:
+            assert isinstance(self._access_counts, dict)
+            return self._access_counts
+        with self.lock:
+            return dict(self._access_counts.items())
+
+    @property
+    def computation_durations(self) -> dict[Hashable, float]:
+        """Return the computation durations of the cache entries."""
+        if not self.shared:
+            assert isinstance(self._computation_durations, dict)
+            return self._computation_durations
+        with self.lock:
+            return dict(self._computation_durations.items())
+
+    def get(self, key: Hashable) -> Any | None:
+        """Retrieve a value from the cache by its key.
+
+        If the key is present in the cache, its access count is incremented.
+
+        Parameters
+        ----------
+        key
+            The key associated with the value in the cache.
+
+        Returns
+        -------
+        Any
+            The value associated with the key if the key is present in the cache,
+            otherwise None.
+        """
+        with self.lock:
+            if key in self._cache:
+                self._access_counts[key] += 1
+                return self._cache[key]
+        return None  # pragma: no cover
+
+    def put(self, key: Hashable, value: Any, duration: float) -> None:
+        """Add a value to the cache with its associated key and computation duration.
+
+        If the cache is full, the entry with the lowest score based on the access
+        frequency and computation duration will be invalidated.
+
+        Parameters
+        ----------
+        key
+            The key associated with the value.
+        value
+            The value to store in the cache.
+        duration
+            The duration of the computation that generated the value.
+        """
+        with self.lock:
+            if len(self._cache) >= self.max_size:
+                self._expire()
+            self._cache[key] = value
+            self._access_counts[key] = 1
+            self._computation_durations[key] = duration
+
+    def _expire(self) -> None:
+        """Invalidate the entry with the lowest score based on the access frequency."""
+        # Calculate normalized access frequencies and computation durations
+        total_access_count = sum(self._access_counts.values())
+        total_duration = sum(self._computation_durations.values())
+        normalized_access_counts = {
+            k: v / total_access_count for k, v in self._access_counts.items()
+        }
+        normalized_durations = {
+            k: v / total_duration for k, v in self._computation_durations.items()
+        }
+
+        # Calculate scores using a weighted sum
+        scores = {
+            k: self.access_weight * normalized_access_counts[k]
+            + self.duration_weight * normalized_durations[k]
+            for k in self._access_counts
+        }
+
+        # Find the key with the lowest score
+        lowest_score_key = min(scores, key=lambda k: scores[k])
+        del self._cache[lowest_score_key]
+        del self._access_counts[lowest_score_key]
+        del self._computation_durations[lowest_score_key]
+
+    def __contains__(self, key: Hashable) -> bool:
+        """Check if a key is present in the cache.
+
+        Parameters
+        ----------
+        key
+            The key to check for in the cache.
+
+        Returns
+        -------
+        bool
+            True if the key is present in the cache, otherwise False.
+        """
+        return key in self._cache
+
+    def __str__(self) -> str:
+        """Return a string representation of the HybridCache.
+
+        The string representation includes information about the cache, access counts,
+        and computation durations for each key.
+
+        Returns
+        -------
+        str
+            A string representation of the HybridCache.
+        """
+        cache_str = f"Cache: {self._cache}\n"
+        access_counts_str = f"Access Counts: {self._access_counts}\n"
+        computation_durations_str = (
+            f"Computation Durations: {self._computation_durations}\n"
+        )
+        return cache_str + access_counts_str + computation_durations_str
+
+
+class LRUCache:
+    """A shared memory LRU cache implementation.
+
+    Parameters
+    ----------
+    max_size
+        Cache size of the LRU cache, by default 128.
+    with_cloudpickle
+        Use cloudpickle for storing the data in memory.
+    shared
+        Whether the cache should be shared between multiple processes.
+    """
+
+    def __init__(
+        self,
+        *,
+        max_size: int = 128,
+        with_cloudpickle: bool = False,
+        shared: bool = True,
+    ) -> None:
+        """Initialize the cache."""
+        self.max_size = max_size
+        self._with_cloudpickle = with_cloudpickle
+        self.shared = shared
+        if max_size == 0:  # pragma: no cover
+            msg = "max_size must be greater than 0"
+            raise ValueError(msg)
+        if shared:
+            manager = Manager()
+            self._cache_dict = manager.dict()
+            self._cache_queue = manager.list()
+            self._cache_lock = manager.Lock()
+        else:
+            self._cache_dict = {}  # type: ignore[assignment]
+            self._cache_queue = []  # type: ignore[assignment]
+            self._cache_lock = nullcontext()  # type: ignore[assignment]
+
+    def get(self, key: Hashable) -> tuple[bool, Any]:
+        """Get a value from the cache by key."""
+        with self._cache_lock:
+            value = self._cache_dict.get(key)
+            if value is not None:  # Move key to back of queue
+                self._cache_queue.remove(key)
+                self._cache_queue.append(key)
+        if value is not None:
+            if value == _NONE_RETURN_STR:
+                value = None
+            elif self._with_cloudpickle:
+                value = cloudpickle.loads(value)
+        return value
+
+    def put(self, key: Hashable, value: Any) -> ListProxy[Any]:
+        """Insert a key value pair into the cache."""
+        if value is None:
+            value = _NONE_RETURN_STR
+        elif self._with_cloudpickle:
+            value = cloudpickle.dumps(value)
+        with self._cache_lock:
+            cache_size = len(self._cache_queue)
+            self._cache_dict[key] = value
+            if cache_size < self.max_size:
+                self._cache_queue.append(key)
+            else:
+                key_to_evict = self._cache_queue.pop(0)
+                self._cache_dict.pop(key_to_evict)
+                self._cache_queue.append(key)
+            return self._cache_queue
+
+    def __contains__(self, key: Hashable) -> bool:
+        """Check if a key is present in the cache."""
+        return key in self._cache_dict
+
+    @property
+    def cache(self) -> dict:
+        """Returns a copy of the cache."""
+        return dict(self._cache_dict.items())