FIX: Add Option to Disable Cache or Set TTL

[aditya306b]

Currently, pyconify automatically creates a cache that loads into RAM, which can lead to excessive memory usage and cause system hangs or performance degradation in long-running applications. There is no built-in way to disable caching or set a time-to-live (TTL) for cached data.

Problem Statement:

• The cache keeps accumulating in RAM, leading to high memory consumption.
• Constantly clearing the cache on every request is not an ideal solution.
• There should be an option to either disable the cache entirely or set an expiration time (TTL) to manage memory usage more efficiently.

Proposed Solution:

• Introduce an optional parameter to disable caching
  Example: @pyconify(use_cache=False)
• Provide a TTL (time-to-live) option for cache expiration
  Example: @pyconify(cache_ttl=300) # Cache expires after 300 seconds

Expected Behavior:

• If use_cache=False, pyconify should bypass cache creation.
• If cache_ttl is set, cached data should automatically expire after the given time, preventing unbounded memory usage.
• The default behavior should remain unchanged for backward compatibility.

Would appreciate your thoughts on this! Thanks for maintaining pyconify. 🚀

[tlambert03]

Thanks for the issue! Will look at this closer soon, but wanted to mention a quick note from the readme section here https://github.com/pyapp-kit/pyconify?tab=readme-ov-file#cache

To disable caching altogether, set the PYCONIFY_CACHE environment variable to false or 0.

[tlambert03]

(But I also like your ideas for non env var…)

[tlambert03]

ok, i've had a moment to take a look.

Currently, pyconify automatically creates a cache that loads into RAM, which can lead to excessive memory usage and cause system hangs or performance degradation in long-running applications.

Can you elaborate on how you measured this? pyconify does cache svg files to disk, but the main object that gets used in api.py is not an in-memory cache, but rather this _SVGCache object, which reads and writes from disk (not memory) during the session.

pyconify/src/pyconify/_cache.py

Lines 71 to 107 in 82e5515

	class _SVGCache(MutableMapping[str, bytes]):
	"""A simple directory cache for SVG files."""
	def __init__(self, directory: str | Path | None = None) -> None:
	super().__init__()
	if not directory:
	directory = get_cache_directory() / "svg_cache" # pragma: no cover
	self.path = Path(directory).expanduser().resolve()
	self.path.mkdir(parents=True, exist_ok=True)
	self._extention = ".svg"
	def path_for(self, _key: str) -> Path:
	return self.path.joinpath(f"{_key}{self._extention}")
	def _svg_files(self) -> Iterator[Path]:
	yield from self.path.glob(f"*{self._extention}")
	def __setitem__(self, _key: str, _value: bytes) -> None:
	self.path_for(_key).write_bytes(_value)
	def __getitem__(self, _key: str) -> bytes:
	try:
	return self.path_for(_key).read_bytes()
	except FileNotFoundError:
	raise KeyError(_key) from None
	def __iter__(self) -> Iterator[str]:
	yield from (x.stem for x in self._svg_files())
	def __delitem__(self, _key: str) -> None:
	self.path_for(_key).unlink()
	def __len__(self) -> int:
	return len(list(self._svg_files()))
	def __contains__(self, _key: object) -> bool:
	return self.path_for(_key).exists() if isinstance(_key, str) else False

However, we also do make liberal usage of functools.cache for calls to the iconify api for metadata, in order to not spam the API (and to improve responsiveness). So in that regard, it is true that if you pull icons from a decent number of different icon collections, I can see that those functools caches might grow

There is no built-in way to disable caching or set a time-to-live (TTL) for cached data.

My original response above of setting PYCONIFY_CACHE=0 does disable the SVG cache (preventing caching to disk), but indeed doesn't disable caching the results of iconify API calls. lru_cache does not support TTL functionality, and i'm hesitant to reimplement that sort of thing here, but it does expose a maxsize parameter which saves up to the maxsize most recent calls. That definitely makes sense to me to expose. (It's not a memory size, it's just the number of recent calls.)

did I understand your issue correctly, and would that be a satisfactory solution?

[tlambert03]

alternatively, we could bring on another dependency and use requests-cache

[aditya306b]

Thanks for your detailed response and clarification! I appreciate and thank you for explaining how caching works in pyconify.

You're right that _SVGCache stores files on disk rather than in RAM, but my concern is more about the functools.cache calls that accumulate over time, especially when dealing with multiple icon collections.

I understand that lru_cache doesn’t support TTL, but exposing the maxsize parameter sounds like a great way to control memory usage. If that can be made configurable (e.g., via a decorator argument or an environment variable), it would help manage cache growth.

Would it be possible to:

- Expose max size as an optional parameter for API call caching?
- Allow users to disable the functools.cache completely, similar to how PYCONIFY_CACHE=0 disables SVG caching?

This way, users can limit cache size or turn it off entirely, depending on their use case. Let me know your thoughts, and thanks again for your responsiveness! 🚀

[tlambert03]

👍 please see my proposed pr at #31

It adds two public functions that I believe cover it

[tlambert03]

available in v0.2.1:

• pyconify.set_api_cache_maxsize(10) - for example ... to restrict the cache to only 10 most recently used calls
• pyconify.set_api_cache_maxsize(0) - for example... to disable caching
• pyconify.clear_api_cache() - to one-time clear the cache, without affecting the cache size