File size: 64,378 Bytes
cb0011e | 1 2 3 4 5 | {"instance_id": "swedl__miniconf-1", "repo": "swedl/miniconf", "base_commit": "f7b5b3a4cfec71e8e6db94c76ae5c4e2ea509216", "patch": "diff --git a/miniconf/config.py b/miniconf/config.py\nindex 8751912..6bdf695 100644\n--- a/miniconf/config.py\n+++ b/miniconf/config.py\n@@ -1,12 +1,8 @@\n \"\"\"The Config object: layered key/value storage with ${...} interpolation.\"\"\"\n \n-import re\n-\n-from .errors import MissingKeyError\n+from .errors import CircularReferenceError, MissingKeyError\n from .loader import load_layers\n \n-REFERENCE = re.compile(r\"\\$\\{([A-Za-z_][A-Za-z0-9_.-]*)\\}\")\n-\n \n class Config:\n \"\"\"A small configuration mapping whose string values may reference keys.\n@@ -51,17 +47,46 @@ class Config:\n \"\"\"Return every key resolved to a plain value.\"\"\"\n return {key: self._resolve(key) for key in self._raw}\n \n- def _resolve(self, key):\n+ def _resolve(self, key, stack=()):\n+ if key in stack:\n+ cycle = stack[stack.index(key):] + (key,)\n+ raise CircularReferenceError(cycle)\n+ if key not in self._raw:\n+ raise MissingKeyError(key, stack[-1] if stack else None)\n value = self._raw[key]\n if not isinstance(value, str):\n return value\n- return self._interpolate(value, key)\n-\n- def _interpolate(self, text, origin):\n- def replace(match):\n- name = match.group(1)\n- if name not in self._raw:\n- raise MissingKeyError(name, origin)\n- return str(self._resolve(name))\n-\n- return REFERENCE.sub(replace, text)\n+ return self._render(value, stack + (key,))\n+\n+ def _render(self, text, stack):\n+ \"\"\"Resolve references in ``text`` in a single left-to-right pass.\"\"\"\n+ out = []\n+ index = 0\n+ length = len(text)\n+ while index < length:\n+ char = text[index]\n+ if char != \"$\":\n+ out.append(char)\n+ index += 1\n+ continue\n+ if text.startswith(\"$$\", index):\n+ out.append(\"$\")\n+ index += 2\n+ continue\n+ if text.startswith(\"${\", index):\n+ end = text.find(\"}\", index + 2)\n+ if end == -1:\n+ out.append(char)\n+ index += 1\n+ continue\n+ name = text[index + 2:end]\n+ if not name:\n+ out.append(char)\n+ index += 1\n+ continue\n+ out.append(str(self._resolve(name, stack)))\n+ index = end + 1\n+ continue\n+ out.append(char)\n+ index += 1\n+ return \"\".join(out)\n", "test_patch": "diff --git a/tests/test_interpolation_edge_cases.py b/tests/test_interpolation_edge_cases.py\nnew file mode 100644\nindex 0000000..6289238\n--- /dev/null\n+++ b/tests/test_interpolation_edge_cases.py\n@@ -0,0 +1,64 @@\n+import pytest\n+\n+from miniconf import CircularReferenceError, Config, MissingKeyError\n+\n+\n+def test_dollar_escape():\n+ cfg = Config({\"price\": \"$${amount}\"})\n+ assert cfg[\"price\"] == \"${amount}\"\n+\n+\n+def test_escape_next_to_reference():\n+ cfg = Config({\"name\": \"wren\", \"msg\": \"$${name} is ${name}\"})\n+ assert cfg[\"msg\"] == \"${name} is wren\"\n+\n+\n+def test_self_reference():\n+ cfg = Config({\"a\": \"x${a}\"})\n+ with pytest.raises(CircularReferenceError):\n+ cfg[\"a\"]\n+\n+\n+def test_as_dict_raises_on_cycle():\n+ cfg = Config({\"a\": \"${b}\", \"b\": \"${a}\"})\n+ with pytest.raises(CircularReferenceError):\n+ cfg.as_dict()\n+\n+\n+def test_cycle_not_involving_requested_key():\n+ cfg = Config({\"a\": \"fine\", \"b\": \"${c}\", \"c\": \"${b}\"})\n+ assert cfg[\"a\"] == \"fine\"\n+ with pytest.raises(CircularReferenceError):\n+ cfg[\"b\"]\n+\n+\n+def test_two_cycle_chain_starts_at_requested_key():\n+ cfg = Config({\"a\": \"${b}\", \"b\": \"${a}\"})\n+ with pytest.raises(CircularReferenceError) as excinfo:\n+ cfg[\"a\"]\n+ assert str(excinfo.value) == \"circular reference: a -> b -> a\"\n+\n+\n+def test_self_reference_message():\n+ cfg = Config({\"loop\": \"${loop}\"})\n+ with pytest.raises(CircularReferenceError) as excinfo:\n+ cfg[\"loop\"]\n+ assert str(excinfo.value) == \"circular reference: loop -> loop\"\n+\n+\n+def test_escaped_text_is_not_reinterpolated_through_a_reference():\n+ cfg = Config({\"inner\": \"$${leak}\", \"outer\": \"${inner}\"})\n+ assert cfg[\"outer\"] == \"${leak}\"\n+\n+\n+def test_missing_key_inside_reference_chain():\n+ cfg = Config({\"a\": \"${b}\", \"b\": \"${nope}\"})\n+ with pytest.raises(MissingKeyError) as excinfo:\n+ cfg[\"a\"]\n+ assert str(excinfo.value) == \"missing key 'nope' referenced from 'b'\"\n+\n+\n+def test_escape_does_not_hide_a_real_cycle():\n+ cfg = Config({\"a\": \"$${b}\", \"b\": \"${a}\"})\n+ assert cfg[\"a\"] == \"${b}\"\n+ assert cfg[\"b\"] == \"${b}\"\n", "problem_statement": "Config interpolation blows up on reference cycles and expands escaped text.\n\nWe use miniconf for service configs that are layered from a shared file plus a\nper-environment overlay. Two problems, both reproducible on main:\n\n1. A cycle anywhere in the mapping crashes with `RecursionError` instead of the\n documented error. `Config({'a': '${b}', 'b': '${a}'})['a']` recurses until the\n interpreter gives up, and the traceback is a thousand frames of `_interpolate`.\n The README says this must raise `CircularReferenceError` with a message naming\n the chain, and we rely on that message in our error reporting.\n\n2. `$$` does not escape. Our TLS config has `cert_subject: \"$${cluster}\"`, meaning\n the literal text `${cluster}` to be handed to a downstream templating tool, but\n miniconf substitutes the cluster name into it. The README's escape rule is not\n implemented at all.\n\nBoth bugs live in `Config._resolve` / `Config._interpolate` in\n`miniconf/config.py`. `README.md` section \"Interpolation contract\" is the spec we\nwant honoured, including the exact wording of the cycle message and the rule that\nsubstituted text is never rescanned for references. A cycle that is unrelated to\nthe key being read must not affect that read, and `as_dict()` must surface cycles\nlike any other read.\n\nThe existing suite passes; the escape and cycle behaviour was never covered.", "hints_text": "", "created_at": "2026-10-30", "version": "1.0", "environment_setup_commit": "f7b5b3a4cfec71e8e6db94c76ae5c4e2ea509216", "FAIL_TO_PASS": "[\"tests/test_interpolation_edge_cases.py::test_as_dict_raises_on_cycle\", \"tests/test_interpolation_edge_cases.py::test_cycle_not_involving_requested_key\", \"tests/test_interpolation_edge_cases.py::test_dollar_escape\", \"tests/test_interpolation_edge_cases.py::test_escape_does_not_hide_a_real_cycle\", \"tests/test_interpolation_edge_cases.py::test_escape_next_to_reference\", \"tests/test_interpolation_edge_cases.py::test_escaped_text_is_not_reinterpolated_through_a_reference\", \"tests/test_interpolation_edge_cases.py::test_self_reference\", \"tests/test_interpolation_edge_cases.py::test_self_reference_message\", \"tests/test_interpolation_edge_cases.py::test_two_cycle_chain_starts_at_requested_key\"]", "PASS_TO_PASS": "[\"tests/test_basic.py::test_as_dict_resolves_all\", \"tests/test_basic.py::test_chained_reference\", \"tests/test_basic.py::test_config_rejects_non_dict\", \"tests/test_basic.py::test_from_layers_override\", \"tests/test_basic.py::test_get_returns_default_for_unknown_key\", \"tests/test_basic.py::test_getitem_raises_keyerror_for_unknown_key\", \"tests/test_basic.py::test_load_layers_rejects_non_dict\", \"tests/test_basic.py::test_missing_key_message\", \"tests/test_basic.py::test_missing_key_raises\", \"tests/test_basic.py::test_non_string_passthrough\", \"tests/test_basic.py::test_plain_values\", \"tests/test_basic.py::test_raw_does_not_resolve\", \"tests/test_basic.py::test_simple_reference\", \"tests/test_basic.py::test_two_references_in_one_value\", \"tests/test_interpolation_edge_cases.py::test_missing_key_inside_reference_chain\"]", "dockerless": {"language": "python", "python_requires": ">=3.9", "install": [], "run_from": ".", "test_cmd": "python -m pytest -v --tb=no -p no:cacheprovider {tests}", "test_files": ["tests/test_basic.py", "tests/test_interpolation_edge_cases.py"], "files": {"miniconf/__init__.py": "\"\"\"miniconf - a tiny layered configuration library with string interpolation.\"\"\"\n\nfrom .config import Config\nfrom .errors import (\n CircularReferenceError,\n ConfigError,\n InterpolationError,\n MissingKeyError,\n)\nfrom .loader import load_layers\n\n__version__ = \"0.4.1\"\n\n__all__ = [\n \"CircularReferenceError\",\n \"Config\",\n \"ConfigError\",\n \"InterpolationError\",\n \"MissingKeyError\",\n \"load_layers\",\n]\n", "miniconf/config.py": "\"\"\"The Config object: layered key/value storage with ${...} interpolation.\"\"\"\n\nimport re\n\nfrom .errors import MissingKeyError\nfrom .loader import load_layers\n\nREFERENCE = re.compile(r\"\\$\\{([A-Za-z_][A-Za-z0-9_.-]*)\\}\")\n\n\nclass Config:\n \"\"\"A small configuration mapping whose string values may reference keys.\n\n See README.md for the interpolation contract.\n \"\"\"\n\n def __init__(self, data):\n if not isinstance(data, dict):\n raise TypeError(\"Config data must be a dict\")\n self._raw = dict(data)\n\n @classmethod\n def from_layers(cls, *layers):\n \"\"\"Build a Config from one or more dict layers, later layers winning.\"\"\"\n return cls(load_layers(*layers))\n\n def raw(self, key, default=None):\n \"\"\"Return the unresolved value stored under ``key``.\"\"\"\n return self._raw.get(key, default)\n\n def keys(self):\n return list(self._raw)\n\n def get(self, key, default=None):\n if key not in self._raw:\n return default\n return self._resolve(key)\n\n def __getitem__(self, key):\n if key not in self._raw:\n raise KeyError(key)\n return self._resolve(key)\n\n def __contains__(self, key):\n return key in self._raw\n\n def __len__(self):\n return len(self._raw)\n\n def as_dict(self):\n \"\"\"Return every key resolved to a plain value.\"\"\"\n return {key: self._resolve(key) for key in self._raw}\n\n def _resolve(self, key):\n value = self._raw[key]\n if not isinstance(value, str):\n return value\n return self._interpolate(value, key)\n\n def _interpolate(self, text, origin):\n def replace(match):\n name = match.group(1)\n if name not in self._raw:\n raise MissingKeyError(name, origin)\n return str(self._resolve(name))\n\n return REFERENCE.sub(replace, text)\n", "miniconf/errors.py": "\"\"\"Exception hierarchy for miniconf.\"\"\"\n\n\nclass ConfigError(Exception):\n \"\"\"Base class for every error raised by miniconf.\"\"\"\n\n\nclass InterpolationError(ConfigError):\n \"\"\"Raised when a ``${...}`` reference cannot be resolved.\"\"\"\n\n\nclass MissingKeyError(InterpolationError):\n \"\"\"Raised when a reference points at a key that does not exist.\"\"\"\n\n def __init__(self, key, referenced_from=None):\n self.key = key\n self.referenced_from = referenced_from\n if referenced_from is None:\n message = \"missing key: %r\" % (key,)\n else:\n message = \"missing key %r referenced from %r\" % (key, referenced_from)\n super().__init__(message)\n\n\nclass CircularReferenceError(InterpolationError):\n \"\"\"Raised when interpolation would loop forever.\"\"\"\n\n def __init__(self, cycle):\n self.cycle = list(cycle)\n super().__init__(\"circular reference: \" + \" -> \".join(self.cycle))\n", "miniconf/loader.py": "\"\"\"Layer merging for miniconf configuration dicts.\"\"\"\n\nfrom .errors import ConfigError\n\n\ndef load_layers(*layers):\n \"\"\"Merge configuration layers left to right; later layers win.\"\"\"\n merged = {}\n for layer in layers:\n if not isinstance(layer, dict):\n raise ConfigError(\"layer must be a dict, got %r\" % (type(layer).__name__,))\n for key, value in layer.items():\n merged[key] = value\n return merged\n", "README.md": "# miniconf\n\nA tiny layered configuration library. Values may reference other keys with\n`${key}` and are resolved lazily on access.\n\n## Interpolation contract\n\nThis is the documented behaviour of `Config`; `tests/` covers the common cases.\n\n1. **References.** A string value may contain any number of `${key}` references.\n The reference is replaced by the *fully resolved* value of `key`, stringified\n with `str()`. References may chain: `a` -> `b` -> `c`.\n2. **Single pass.** Substituted text is never scanned again for references. If\n `inner` resolves to the literal text `${leak}`, then `\"${inner}\"` resolves to\n `${leak}` and not to the value of `leak`.\n3. **Escaping.** `$$` is an escape that produces a single literal `$`. It never\n starts a reference, so `\"$${amount}\"` resolves to the five characters\n `${amount}` — the reference is *not* expanded. `\"$${name} is ${name}\"` with\n `name=wren` resolves to `\"${name} is wren\"`.\n4. **Cycles.** A reference cycle, including a self reference such as\n `a = \"x${a}\"`, must raise `CircularReferenceError` instead of recursing. The\n message is `\"circular reference: \"` followed by the key chain joined with\n `\" -> \"`, starting at the key the caller asked for and ending with that same\n key repeated. Asking for `a` where `a -> b -> a` raises\n `\"circular reference: a -> b -> a\"`; asking for `a` where `a -> a` raises\n `\"circular reference: a -> a\"`.\n5. **Missing keys.** A reference to an unknown key raises `MissingKeyError`.\n6. **Non-string values** are returned as-is and are never scanned.\n\n`Config.as_dict()` resolves every key, so any cycle or missing reference in the\nmapping surfaces there too. A cycle that is unrelated to the key being read must\nnot affect that read: with `a=\"fine\"`, `b=\"${c}\"`, `c=\"${b}\"`, reading `a` still\nreturns `\"fine\"` while reading `b` raises.\n\n## Usage\n\n```python\nfrom miniconf import Config\n\ncfg = Config.from_layers(\n {\"host\": \"localhost\", \"port\": 8080},\n {\"url\": \"http://${host}:${port}/\"},\n)\ncfg[\"url\"] # 'http://localhost:8080/'\ncfg.as_dict() # {'host': 'localhost', 'port': 8080, 'url': 'http://localhost:8080/'}\n```\n\n## Tests\n\n```\npython -m pytest -q\n```\n", "tests/test_basic.py": "import pytest\n\nfrom miniconf import Config, ConfigError, MissingKeyError, load_layers\n\n\ndef test_plain_values():\n cfg = Config({\"name\": \"app\", \"port\": 8080})\n assert cfg[\"name\"] == \"app\"\n assert cfg[\"port\"] == 8080\n assert len(cfg) == 2\n\n\ndef test_simple_reference():\n cfg = Config({\"host\": \"localhost\", \"url\": \"http://${host}/\"})\n assert cfg[\"url\"] == \"http://localhost/\"\n\n\ndef test_two_references_in_one_value():\n cfg = Config({\"host\": \"db\", \"port\": 5432, \"dsn\": \"${host}:${port}\"})\n assert cfg[\"dsn\"] == \"db:5432\"\n\n\ndef test_chained_reference():\n cfg = Config({\"a\": \"x\", \"b\": \"${a}-y\", \"c\": \"${b}-z\"})\n assert cfg[\"c\"] == \"x-y-z\"\n\n\ndef test_missing_key_raises():\n cfg = Config({\"a\": \"${nope}\"})\n with pytest.raises(MissingKeyError):\n cfg[\"a\"]\n\n\ndef test_missing_key_message():\n cfg = Config({\"a\": \"${nope}\"})\n with pytest.raises(MissingKeyError) as excinfo:\n cfg[\"a\"]\n assert str(excinfo.value) == \"missing key 'nope' referenced from 'a'\"\n\n\ndef test_non_string_passthrough():\n cfg = Config({\"n\": 3, \"flag\": True, \"nested\": {\"x\": 1}})\n assert cfg[\"n\"] == 3\n assert cfg[\"flag\"] is True\n assert cfg[\"nested\"] == {\"x\": 1}\n\n\ndef test_get_returns_default_for_unknown_key():\n cfg = Config({\"a\": \"1\"})\n assert cfg.get(\"zzz\") is None\n assert cfg.get(\"zzz\", \"dflt\") == \"dflt\"\n\n\ndef test_getitem_raises_keyerror_for_unknown_key():\n cfg = Config({\"a\": \"1\"})\n with pytest.raises(KeyError):\n cfg[\"zzz\"]\n\n\ndef test_raw_does_not_resolve():\n cfg = Config({\"a\": \"1\", \"b\": \"${a}\"})\n assert cfg.raw(\"b\") == \"${a}\"\n\n\ndef test_from_layers_override():\n cfg = Config.from_layers({\"a\": \"1\", \"b\": \"2\"}, {\"b\": \"3\"})\n assert cfg.as_dict() == {\"a\": \"1\", \"b\": \"3\"}\n\n\ndef test_load_layers_rejects_non_dict():\n with pytest.raises(ConfigError):\n load_layers({\"a\": 1}, [\"not\", \"a\", \"dict\"])\n\n\ndef test_as_dict_resolves_all():\n cfg = Config({\"a\": \"1\", \"b\": \"${a}2\"})\n assert cfg.as_dict() == {\"a\": \"1\", \"b\": \"12\"}\n\n\ndef test_config_rejects_non_dict():\n with pytest.raises(TypeError):\n Config([(\"a\", 1)])\n"}}}
{"instance_id": "swedl__ttlcache-1", "repo": "swedl/ttlcache", "base_commit": "7c1d3594fec009ac3cf7ef48506ec6d3b0d56132", "patch": "diff --git a/ttlcache/cache.py b/ttlcache/cache.py\nindex fda1724..4c36ad4 100644\n--- a/ttlcache/cache.py\n+++ b/ttlcache/cache.py\n@@ -28,8 +28,15 @@ class TTLCache:\n def _expired(deadline, now):\n return now >= deadline\n \n+ def _purge(self, now):\n+ \"\"\"Drop every expired entry so it can never be counted or evicted.\"\"\"\n+ stale = [key for key, (_, deadline) in self._data.items() if self._expired(deadline, now)]\n+ for key in stale:\n+ del self._data[key]\n+\n def __len__(self):\n- return len(self._data)\n+ now = self._now()\n+ return sum(1 for _, deadline in self._data.values() if not self._expired(deadline, now))\n \n def __contains__(self, key):\n if key not in self._data:\n@@ -39,6 +46,9 @@ class TTLCache:\n \n def __setitem__(self, key, value):\n now = self._now()\n+ self._purge(now)\n+ if key in self._data:\n+ del self._data[key]\n self._data[key] = (value, now + self.ttl)\n while len(self._data) > self.maxsize:\n self._data.popitem(last=False)\n@@ -48,6 +58,7 @@ class TTLCache:\n if self._expired(deadline, self._now()):\n del self._data[key]\n raise KeyError(key)\n+ self._data.move_to_end(key)\n return value\n \n def get(self, key, default=None):\n", "test_patch": "diff --git a/tests/test_lru_semantics.py b/tests/test_lru_semantics.py\nnew file mode 100644\nindex 0000000..1563011\n--- /dev/null\n+++ b/tests/test_lru_semantics.py\n@@ -0,0 +1,55 @@\n+from ttlcache import FakeClock, TTLCache\n+\n+\n+def test_get_refreshes_recency():\n+ clock = FakeClock()\n+ cache = TTLCache(maxsize=2, ttl=10.0, clock=clock)\n+ cache[\"a\"] = 1\n+ cache[\"b\"] = 2\n+ assert cache[\"a\"] == 1\n+ cache[\"c\"] = 3\n+ assert \"a\" in cache\n+ assert \"b\" not in cache\n+\n+\n+def test_overwrite_refreshes_recency():\n+ clock = FakeClock()\n+ cache = TTLCache(maxsize=2, ttl=10.0, clock=clock)\n+ cache[\"a\"] = 1\n+ cache[\"b\"] = 2\n+ cache[\"a\"] = 9\n+ cache[\"c\"] = 3\n+ assert cache[\"a\"] == 9\n+ assert \"b\" not in cache\n+\n+\n+def test_setdefault_refreshes_recency():\n+ clock = FakeClock()\n+ cache = TTLCache(maxsize=2, ttl=10.0, clock=clock)\n+ cache[\"a\"] = 1\n+ cache[\"b\"] = 2\n+ assert cache.setdefault(\"a\", lambda: 99) == 1\n+ cache[\"c\"] = 3\n+ assert \"a\" in cache\n+ assert \"b\" not in cache\n+\n+\n+def test_len_ignores_expired_entries():\n+ clock = FakeClock()\n+ cache = TTLCache(maxsize=4, ttl=10.0, clock=clock)\n+ cache[\"a\"] = 1\n+ clock.advance(5)\n+ cache[\"b\"] = 2\n+ clock.advance(6)\n+ assert len(cache) == 1\n+ assert \"a\" not in cache\n+ assert \"b\" in cache\n+\n+\n+def test_items_reports_least_recently_used_first():\n+ clock = FakeClock()\n+ cache = TTLCache(maxsize=3, ttl=10.0, clock=clock)\n+ cache[\"a\"] = 1\n+ cache[\"b\"] = 2\n+ assert cache[\"a\"] == 1\n+ assert list(cache.items()) == [(\"b\", 2), (\"a\", 1)]\n", "problem_statement": "LRU eviction ignores reads, and len() counts entries that already expired.\n\nOur request cache is a `TTLCache(maxsize=N, ttl=...)` and it is evicting the wrong\nkeys under load:\n\n1. Reading a key does not protect it. With `maxsize=2`, writing `a`, `b`, reading\n `a`, then writing `c` drops `a` and keeps `b` -- the exact opposite of LRU. The\n same happens when a key is overwritten: the new write keeps the old position\n instead of becoming the most recently used entry.\n\n2. `len(cache)` returns the number of stored rows, including rows whose TTL already\n elapsed. Our metrics dashboard reports a cache that never shrinks even though\n every read says the key is gone.\n\n3. `items()` order does not reflect access order for the same reason.\n\n`README.md` documents the intended contract (sections 2-5): reads and overwrites\nmark an entry most-recently-used, expired entries are purged before eviction\nhappens, and `len()` counts live entries only. `ttlcache/cache.py` is the file to\nfix; `ttlcache/clock.py` already gives you a deterministic `FakeClock`.\n\nBe careful that expiry still deletes the entry on read and that `get()` keeps\nreturning its default for missing keys.", "hints_text": "", "created_at": "2026-10-30", "version": "1.0", "environment_setup_commit": "7c1d3594fec009ac3cf7ef48506ec6d3b0d56132", "FAIL_TO_PASS": "[\"tests/test_lru_semantics.py::test_get_refreshes_recency\", \"tests/test_lru_semantics.py::test_items_reports_least_recently_used_first\", \"tests/test_lru_semantics.py::test_len_ignores_expired_entries\", \"tests/test_lru_semantics.py::test_overwrite_refreshes_recency\", \"tests/test_lru_semantics.py::test_setdefault_refreshes_recency\"]", "PASS_TO_PASS": "[\"tests/test_cache.py::test_entry_expires\", \"tests/test_cache.py::test_entry_survives_before_deadline\", \"tests/test_cache.py::test_eviction_order_on_insert\", \"tests/test_cache.py::test_getitem_raises_for_missing_key\", \"tests/test_cache.py::test_invalid_arguments\", \"tests/test_cache.py::test_items_skips_expired\", \"tests/test_cache.py::test_missing_key_returns_default\", \"tests/test_cache.py::test_overwrite_updates_value\", \"tests/test_cache.py::test_pop_removes_entry\", \"tests/test_cache.py::test_repr_reports_live_count\", \"tests/test_cache.py::test_set_and_get\", \"tests/test_cache.py::test_setdefault_uses_factory_once\"]", "dockerless": {"language": "python", "python_requires": ">=3.9", "install": [], "run_from": ".", "test_cmd": "python -m pytest -v --tb=no -p no:cacheprovider {tests}", "test_files": ["tests/test_cache.py", "tests/test_lru_semantics.py"], "files": {"README.md": "# ttlcache\n\nA bounded cache with per-entry time-to-live and LRU eviction. The cache never\nreads the system clock directly; pass a `clock` object exposing `now()` (see\n`ttlcache.clock.FakeClock`) so expiry is deterministic under test.\n\n## Contract\n\n1. **Expiry.** An entry written at time `t` is live while `now < t + ttl` and\n expired once `now >= t + ttl`. Reading an expired key deletes it and raises\n `KeyError` (`get` returns its default instead). `key in cache` is `False` for\n expired entries.\n2. **Recency.** `__getitem__`, `get` and `setdefault` mark the entry as most\n recently used. Writing an existing key also moves it to the most-recently-used\n end *and* restarts its TTL.\n3. **Eviction.** When a write would exceed `maxsize`, expired entries are dropped\n first; if the cache is still full, the least recently used live entry is\n dropped.\n4. **`len(cache)`** counts live entries only. Expired-but-not-yet-collected\n entries must not inflate the count.\n5. **`items()`** yields live pairs in LRU order (least recently used first).\n\n## Usage\n\n```python\nfrom ttlcache import FakeClock, TTLCache\n\nclock = FakeClock()\ncache = TTLCache(maxsize=2, ttl=10.0, clock=clock)\ncache[\"a\"] = 1\ncache[\"b\"] = 2\ncache[\"a\"] # 'a' is now most recently used\ncache[\"c\"] = 3 # evicts 'b', not 'a'\n```\n\n## Tests\n\n```\npython -m pytest -q\n```\n", "tests/test_cache.py": "import pytest\n\nfrom ttlcache import FakeClock, TTLCache\n\n\ndef make(clock, maxsize=3, ttl=10.0):\n return TTLCache(maxsize=maxsize, ttl=ttl, clock=clock)\n\n\ndef test_set_and_get():\n clock = FakeClock()\n cache = make(clock)\n cache[\"a\"] = 1\n assert cache[\"a\"] == 1\n assert cache.get(\"a\") == 1\n\n\ndef test_missing_key_returns_default():\n cache = make(FakeClock())\n assert cache.get(\"nope\") is None\n assert cache.get(\"nope\", 7) == 7\n\n\ndef test_getitem_raises_for_missing_key():\n cache = make(FakeClock())\n with pytest.raises(KeyError):\n cache[\"nope\"]\n\n\ndef test_entry_expires():\n clock = FakeClock()\n cache = make(clock)\n cache[\"a\"] = 1\n clock.advance(10)\n assert \"a\" not in cache\n assert cache.get(\"a\") is None\n with pytest.raises(KeyError):\n cache[\"a\"]\n\n\ndef test_entry_survives_before_deadline():\n clock = FakeClock()\n cache = make(clock)\n cache[\"a\"] = 1\n clock.advance(9.5)\n assert cache[\"a\"] == 1\n\n\ndef test_eviction_order_on_insert():\n clock = FakeClock()\n cache = make(clock, maxsize=2)\n cache[\"a\"] = 1\n cache[\"b\"] = 2\n cache[\"c\"] = 3\n assert \"a\" not in cache\n assert \"b\" in cache and \"c\" in cache\n\n\ndef test_overwrite_updates_value():\n clock = FakeClock()\n cache = make(clock)\n cache[\"a\"] = 1\n cache[\"a\"] = 2\n assert cache[\"a\"] == 2\n assert len(cache) == 1\n\n\ndef test_setdefault_uses_factory_once():\n clock = FakeClock()\n cache = make(clock)\n calls = []\n\n def factory():\n calls.append(1)\n return \"v\"\n\n assert cache.setdefault(\"k\", factory) == \"v\"\n assert cache.setdefault(\"k\", factory) == \"v\"\n assert len(calls) == 1\n\n\ndef test_pop_removes_entry():\n clock = FakeClock()\n cache = make(clock)\n cache[\"a\"] = 1\n assert cache.pop(\"a\") == 1\n assert cache.pop(\"a\", \"gone\") == \"gone\"\n\n\ndef test_items_skips_expired():\n clock = FakeClock()\n cache = make(clock)\n cache[\"a\"] = 1\n clock.advance(4)\n cache[\"b\"] = 2\n clock.advance(7)\n assert list(cache.items()) == [(\"b\", 2)]\n\n\ndef test_invalid_arguments():\n with pytest.raises(ValueError):\n TTLCache(maxsize=0)\n with pytest.raises(ValueError):\n TTLCache(ttl=0)\n\n\ndef test_repr_reports_live_count():\n clock = FakeClock()\n cache = make(clock)\n cache[\"a\"] = 1\n assert \"live=1\" in repr(cache)\n", "ttlcache/__init__.py": "\"\"\"ttlcache - a bounded TTL + LRU cache.\"\"\"\n\nfrom .cache import TTLCache\nfrom .clock import FakeClock, SystemClock\n\n__version__ = \"0.3.0\"\n\n__all__ = [\"FakeClock\", \"SystemClock\", \"TTLCache\"]\n", "ttlcache/cache.py": "\"\"\"A bounded cache with per-entry time-to-live and LRU eviction.\"\"\"\n\nfrom collections import OrderedDict\n\n\nclass TTLCache:\n \"\"\"Fixed-capacity cache where every entry expires ``ttl`` seconds after write.\n\n Entries are kept in least-recently-used order. When the cache is full the\n least recently used entry is dropped first. See README.md for the full\n contract.\n \"\"\"\n\n def __init__(self, maxsize=128, ttl=60.0, clock=None):\n if maxsize <= 0:\n raise ValueError(\"maxsize must be positive\")\n if ttl <= 0:\n raise ValueError(\"ttl must be positive\")\n self.maxsize = maxsize\n self.ttl = float(ttl)\n self._clock = clock\n self._data = OrderedDict()\n\n def _now(self):\n return self._clock.now() if self._clock is not None else 0.0\n\n @staticmethod\n def _expired(deadline, now):\n return now >= deadline\n\n def __len__(self):\n return len(self._data)\n\n def __contains__(self, key):\n if key not in self._data:\n return False\n _, deadline = self._data[key]\n return not self._expired(deadline, self._now())\n\n def __setitem__(self, key, value):\n now = self._now()\n self._data[key] = (value, now + self.ttl)\n while len(self._data) > self.maxsize:\n self._data.popitem(last=False)\n\n def __getitem__(self, key):\n value, deadline = self._data[key]\n if self._expired(deadline, self._now()):\n del self._data[key]\n raise KeyError(key)\n return value\n\n def get(self, key, default=None):\n try:\n return self[key]\n except KeyError:\n return default\n\n def setdefault(self, key, factory):\n \"\"\"Return the live value for ``key``, computing and storing it if absent.\"\"\"\n if key in self:\n return self[key]\n value = factory()\n self[key] = value\n return value\n\n def pop(self, key, default=None):\n if key not in self._data:\n return default\n value, _ = self._data.pop(key)\n return value\n\n def items(self):\n \"\"\"Iterate over live ``(key, value)`` pairs in LRU order.\"\"\"\n now = self._now()\n return [(k, v) for k, (v, d) in self._data.items() if not self._expired(d, now)]\n\n def __repr__(self):\n return \"TTLCache(maxsize=%d, ttl=%r, live=%d)\" % (\n self.maxsize,\n self.ttl,\n len(self),\n )\n", "ttlcache/clock.py": "\"\"\"Clocks used by ttlcache.\n\nThe cache never calls ``time`` directly: it asks a clock object for the current\ntime, which makes expiry deterministic in tests.\n\"\"\"\n\nimport time\n\n\nclass SystemClock:\n \"\"\"Monotonic wall clock for production use.\"\"\"\n\n def now(self):\n return time.monotonic()\n\n\nclass FakeClock:\n \"\"\"A clock that only moves when you tell it to.\"\"\"\n\n def __init__(self, start=0.0):\n self._now = float(start)\n\n def now(self):\n return self._now\n\n def advance(self, seconds):\n self._now += float(seconds)\n return self._now\n"}}}
{"instance_id": "swedl__cronlite-1", "repo": "swedl/cronlite", "base_commit": "cb8cd4f111a02d9358774debe834b530bcbfeb94", "patch": "diff --git a/cronlite/fields.py b/cronlite/fields.py\nindex 4945d5e..b3c0eb6 100644\n--- a/cronlite/fields.py\n+++ b/cronlite/fields.py\n@@ -1,13 +1,19 @@\n \"\"\"Parsing of individual cron fields into sets of integers.\"\"\"\n \n \n+def _sunday_alias(value):\n+ \"\"\"Collapse the cron Sunday alias 7 onto 0.\"\"\"\n+ return 0 if value == 7 else value\n+\n+\n class FieldSpec:\n \"\"\"Describes one of the five cron fields.\"\"\"\n \n- def __init__(self, name, minimum, maximum):\n+ def __init__(self, name, minimum, maximum, normalize=None):\n self.name = name\n self.minimum = minimum\n self.maximum = maximum\n+ self.normalize = normalize\n \n def _check(self, value):\n if value < self.minimum or value > self.maximum:\n@@ -23,6 +29,8 @@ class FieldSpec:\n values |= self._parse_part(part)\n if not values:\n raise ValueError(\"empty %s field\" % self.name)\n+ if self.normalize is not None:\n+ values = {self.normalize(value) for value in values}\n return values\n \n def _parse_part(self, part):\n@@ -42,7 +50,7 @@ class FieldSpec:\n start, stop = self._parse_bounds(base)\n else:\n start = self._check(int(base))\n- stop = start\n+ stop = self.maximum\n return set(range(start, stop + 1, step))\n if \"-\" in part:\n start, stop = self._parse_bounds(part)\n@@ -66,7 +74,7 @@ MINUTE = FieldSpec(\"minute\", 0, 59)\n HOUR = FieldSpec(\"hour\", 0, 23)\n DAY_OF_MONTH = FieldSpec(\"day_of_month\", 1, 31)\n MONTH = FieldSpec(\"month\", 1, 12)\n-DAY_OF_WEEK = FieldSpec(\"day_of_week\", 0, 6)\n+DAY_OF_WEEK = FieldSpec(\"day_of_week\", 0, 7, normalize=_sunday_alias)\n \n \n def parse_field(spec, text):\n", "test_patch": "diff --git a/tests/test_step_and_sunday.py b/tests/test_step_and_sunday.py\nnew file mode 100644\nindex 0000000..7529ebc\n--- /dev/null\n+++ b/tests/test_step_and_sunday.py\n@@ -0,0 +1,43 @@\n+from datetime import datetime\n+\n+from cronlite import CronExpression, next_after\n+from cronlite.fields import DAY_OF_WEEK, MINUTE, parse_field\n+\n+\n+def test_single_value_with_step_runs_to_end_of_range():\n+ assert parse_field(MINUTE, \"5/15\") == {5, 20, 35, 50}\n+\n+\n+def test_single_value_with_step_stops_at_field_maximum():\n+ assert parse_field(MINUTE, \"58/5\") == {58}\n+\n+\n+def test_next_after_with_stepped_start():\n+ expr = CronExpression(\"5/20 * * * *\")\n+ assert next_after(expr, datetime(2026, 3, 4, 0, 6)) == datetime(2026, 3, 4, 0, 25)\n+\n+\n+def test_sunday_may_be_written_as_seven():\n+ assert parse_field(DAY_OF_WEEK, \"7\") == {0}\n+\n+\n+def test_zero_and_seven_are_equivalent():\n+ assert parse_field(DAY_OF_WEEK, \"0\") == parse_field(DAY_OF_WEEK, \"7\")\n+\n+\n+def test_weekend_range_ending_in_seven():\n+ assert parse_field(DAY_OF_WEEK, \"6-7\") == {6, 0}\n+\n+\n+def test_seven_inside_a_list():\n+ assert parse_field(DAY_OF_WEEK, \"1,7\") == {1, 0}\n+\n+\n+def test_next_after_sunday_seven():\n+ expr = CronExpression(\"0 12 * * 7\")\n+ assert next_after(expr, datetime(2026, 3, 4, 0, 0)) == datetime(2026, 3, 8, 12, 0)\n+\n+\n+def test_weekend_range_next_run():\n+ expr = CronExpression(\"0 9 * * 6-7\")\n+ assert next_after(expr, datetime(2026, 3, 6, 0, 0)) == datetime(2026, 3, 7, 9, 0)\n", "problem_statement": "`5/15` in the minute field only fires once an hour, and day-of-week 7 is rejected.\n\nTwo field-parsing bugs, both in `cronlite/fields.py`:\n\n1. A single value followed by a step is treated as a one-element set. `5/15`\n parses to `{5}` instead of `{5, 20, 35, 50}`, so a job scheduled at\n `5/20 * * * *` runs at 00:05, 01:05, 02:05 instead of every twenty minutes\n starting at :05. `*/20` and `1-10/3` are correct -- only the `<value>/<step>`\n form is wrong, because the upper bound collapses to the start value.\n\n2. Sunday cannot be written as 7. `0 12 * * 7` raises\n `ValueError: day_of_week value out of range: 7` at construction time, and so do\n `7`, `1,7` and `6-7`. Standard cron accepts 0-7 for that field with both 0 and 7\n meaning Sunday. The README's \"Day of week\" section asks for the 7 alias to be\n accepted everywhere a value is accepted and collapsed onto 0, so that a parsed\n day-of-week set is always expressed on the 0-6 scale (`6-7` -> `{6, 0}`).\n\nEverything else about the field syntax must keep working, including the existing\nrange checks and the descending-range rejection.", "hints_text": "", "created_at": "2026-10-30", "version": "1.0", "environment_setup_commit": "cb8cd4f111a02d9358774debe834b530bcbfeb94", "FAIL_TO_PASS": "[\"tests/test_step_and_sunday.py::test_next_after_sunday_seven\", \"tests/test_step_and_sunday.py::test_next_after_with_stepped_start\", \"tests/test_step_and_sunday.py::test_seven_inside_a_list\", \"tests/test_step_and_sunday.py::test_single_value_with_step_runs_to_end_of_range\", \"tests/test_step_and_sunday.py::test_sunday_may_be_written_as_seven\", \"tests/test_step_and_sunday.py::test_weekend_range_ending_in_seven\", \"tests/test_step_and_sunday.py::test_weekend_range_next_run\", \"tests/test_step_and_sunday.py::test_zero_and_seven_are_equivalent\"]", "PASS_TO_PASS": "[\"tests/test_basic.py::test_bad_step_rejected\", \"tests/test_basic.py::test_cron_weekday_mapping\", \"tests/test_basic.py::test_descending_range_rejected\", \"tests/test_basic.py::test_invalid_field_count\", \"tests/test_basic.py::test_list_field\", \"tests/test_basic.py::test_list_with_range\", \"tests/test_basic.py::test_matches_every_minute\", \"tests/test_basic.py::test_matches_rejects_wrong_minute\", \"tests/test_basic.py::test_next_after_accepts_string\", \"tests/test_basic.py::test_next_after_basic\", \"tests/test_basic.py::test_next_after_is_strict\", \"tests/test_basic.py::test_next_after_rolls_to_next_day\", \"tests/test_basic.py::test_out_of_range_rejected\", \"tests/test_basic.py::test_range_field\", \"tests/test_basic.py::test_range_step_field\", \"tests/test_basic.py::test_single_value_field\", \"tests/test_basic.py::test_star_field\", \"tests/test_basic.py::test_star_step_field\", \"tests/test_basic.py::test_str_roundtrip\", \"tests/test_basic.py::test_weekday_field_within_zero_to_six\", \"tests/test_step_and_sunday.py::test_single_value_with_step_stops_at_field_maximum\"]", "dockerless": {"language": "python", "python_requires": ">=3.9", "install": [], "run_from": ".", "test_cmd": "python -m pytest -v --tb=no -p no:cacheprovider {tests}", "test_files": ["tests/test_basic.py", "tests/test_step_and_sunday.py"], "files": {"cronlite/__init__.py": "\"\"\"cronlite - a dependency-free five-field cron expression evaluator.\"\"\"\n\nfrom .expr import CronExpression, cron_weekday, next_after\nfrom .fields import (\n DAY_OF_MONTH,\n DAY_OF_WEEK,\n HOUR,\n MINUTE,\n MONTH,\n FieldSpec,\n parse_field,\n)\n\n__version__ = \"0.2.3\"\n\n__all__ = [\n \"CronExpression\",\n \"DAY_OF_MONTH\",\n \"DAY_OF_WEEK\",\n \"FieldSpec\",\n \"HOUR\",\n \"MINUTE\",\n \"MONTH\",\n \"cron_weekday\",\n \"next_after\",\n \"parse_field\",\n]\n", "cronlite/expr.py": "\"\"\"A five-field cron expression evaluator.\"\"\"\n\nfrom datetime import timedelta\n\nfrom .fields import DAY_OF_MONTH, DAY_OF_WEEK, HOUR, MINUTE, MONTH, parse_field\n\nSEARCH_LIMIT_DAYS = 366\n\n\ndef cron_weekday(moment):\n \"\"\"Return the cron weekday of ``moment``: 0 = Sunday, 6 = Saturday.\"\"\"\n return (moment.weekday() + 1) % 7\n\n\nclass CronExpression:\n \"\"\"A parsed ``minute hour day-of-month month day-of-week`` expression.\"\"\"\n\n def __init__(self, expression):\n parts = expression.split()\n if len(parts) != 5:\n raise ValueError(\"expected 5 fields, got %d\" % (len(parts),))\n self.expression = \" \".join(parts)\n self.minutes = parse_field(MINUTE, parts[0])\n self.hours = parse_field(HOUR, parts[1])\n self.days = parse_field(DAY_OF_MONTH, parts[2])\n self.months = parse_field(MONTH, parts[3])\n self.weekdays = parse_field(DAY_OF_WEEK, parts[4])\n\n def matches(self, moment):\n return (\n moment.minute in self.minutes\n and moment.hour in self.hours\n and moment.day in self.days\n and moment.month in self.months\n and cron_weekday(moment) in self.weekdays\n )\n\n def next_after(self, moment):\n \"\"\"Return the first matching minute strictly after ``moment``.\"\"\"\n current = moment.replace(second=0, microsecond=0) + timedelta(minutes=1)\n limit = current + timedelta(days=SEARCH_LIMIT_DAYS)\n while current <= limit:\n if self.matches(current):\n return current\n current += timedelta(minutes=1)\n raise ValueError(\"no matching time within %d days\" % SEARCH_LIMIT_DAYS)\n\n def __str__(self):\n return self.expression\n\n def __repr__(self):\n return \"CronExpression(%r)\" % (self.expression,)\n\n\ndef next_after(expression, moment):\n \"\"\"Convenience wrapper: ``next_after(\"*/5 * * * *\", moment)``.\"\"\"\n if not isinstance(expression, CronExpression):\n expression = CronExpression(expression)\n return expression.next_after(moment)\n", "cronlite/fields.py": "\"\"\"Parsing of individual cron fields into sets of integers.\"\"\"\n\n\nclass FieldSpec:\n \"\"\"Describes one of the five cron fields.\"\"\"\n\n def __init__(self, name, minimum, maximum):\n self.name = name\n self.minimum = minimum\n self.maximum = maximum\n\n def _check(self, value):\n if value < self.minimum or value > self.maximum:\n raise ValueError(\"%s value out of range: %d\" % (self.name, value))\n return value\n\n def parse(self, text):\n values = set()\n for part in text.split(\",\"):\n part = part.strip()\n if not part:\n raise ValueError(\"empty %s component\" % self.name)\n values |= self._parse_part(part)\n if not values:\n raise ValueError(\"empty %s field\" % self.name)\n return values\n\n def _parse_part(self, part):\n if part == \"*\":\n return set(range(self.minimum, self.maximum + 1))\n if \"/\" in part:\n base, _, step_text = part.partition(\"/\")\n try:\n step = int(step_text)\n except ValueError:\n raise ValueError(\"invalid step in %s field: %r\" % (self.name, part))\n if step <= 0:\n raise ValueError(\"step must be positive in %s field\" % self.name)\n if base == \"*\":\n start, stop = self.minimum, self.maximum\n elif \"-\" in base:\n start, stop = self._parse_bounds(base)\n else:\n start = self._check(int(base))\n stop = start\n return set(range(start, stop + 1, step))\n if \"-\" in part:\n start, stop = self._parse_bounds(part)\n return set(range(start, stop + 1))\n return {self._check(int(part))}\n\n def _parse_bounds(self, text):\n low, _, high = text.partition(\"-\")\n try:\n start, stop = int(low), int(high)\n except ValueError:\n raise ValueError(\"invalid range in %s field: %r\" % (self.name, text))\n self._check(start)\n self._check(stop)\n if stop < start:\n raise ValueError(\"descending range in %s field: %r\" % (self.name, text))\n return start, stop\n\n\nMINUTE = FieldSpec(\"minute\", 0, 59)\nHOUR = FieldSpec(\"hour\", 0, 23)\nDAY_OF_MONTH = FieldSpec(\"day_of_month\", 1, 31)\nMONTH = FieldSpec(\"month\", 1, 12)\nDAY_OF_WEEK = FieldSpec(\"day_of_week\", 0, 6)\n\n\ndef parse_field(spec, text):\n \"\"\"Parse ``text`` against ``spec`` and return the matching values.\"\"\"\n return spec.parse(text)\n", "README.md": "# cronlite\n\nA dependency-free evaluator for standard five-field cron expressions:\n\n```\nminute hour day-of-month month day-of-week\n```\n\n## Field syntax\n\n| Form | Meaning |\n| --- | --- |\n| `*` | every value in the field range |\n| `7` | a single value |\n| `1-5` | an inclusive range |\n| `*/15` | every 15th value across the whole range |\n| `1-10/3` | every 3rd value inside the range (`1, 4, 7, 10`) |\n| `5/15` | every 15th value starting at 5 and **running to the end of the range** (`5, 20, 35, 50`) |\n| `0,15,30` | a list; any of the above forms may be combined in a list |\n\nField ranges: minute `0-59`, hour `0-23`, day-of-month `1-31`, month `1-12`.\n\n## Day of week\n\nThe day-of-week field is `0-7` where **both `0` and `7` mean Sunday** and\n`1-6` mean Monday to Saturday. `7` must be accepted anywhere a value is\naccepted, including inside ranges such as `6-7` (Saturday and Sunday), and it\nmust behave exactly like `0`. Internally a parsed day-of-week set is expressed\non the `0-6` scale, so `parse_field(DAY_OF_WEEK, \"7\") == {0}` and\n`parse_field(DAY_OF_WEEK, \"6-7\") == {6, 0}`.\n\n## Matching\n\n`CronExpression.matches(moment)` is true when all five fields match. The\nday-of-month and day-of-week fields are combined with AND (not the traditional\nOR). `next_after(moment)` returns the first matching minute strictly after\n`moment`, scanning forward up to 366 days.\n\n## Tests\n\n```\npython -m pytest -q\n```\n", "tests/test_basic.py": "from datetime import datetime\n\nimport pytest\n\nfrom cronlite import CronExpression, cron_weekday, next_after\nfrom cronlite.fields import DAY_OF_WEEK, HOUR, MINUTE, parse_field\n\n\ndef test_star_field():\n assert parse_field(MINUTE, \"*\") == set(range(60))\n\n\ndef test_single_value_field():\n assert parse_field(MINUTE, \"17\") == {17}\n\n\ndef test_list_field():\n assert parse_field(MINUTE, \"0,15,30,45\") == {0, 15, 30, 45}\n\n\ndef test_list_with_range():\n assert parse_field(MINUTE, \"0,10-12\") == {0, 10, 11, 12}\n\n\ndef test_range_field():\n assert parse_field(HOUR, \"9-11\") == {9, 10, 11}\n\n\ndef test_star_step_field():\n assert parse_field(MINUTE, \"*/15\") == {0, 15, 30, 45}\n\n\ndef test_range_step_field():\n assert parse_field(MINUTE, \"1-10/3\") == {1, 4, 7, 10}\n\n\ndef test_out_of_range_rejected():\n with pytest.raises(ValueError):\n parse_field(MINUTE, \"60\")\n with pytest.raises(ValueError):\n parse_field(HOUR, \"24\")\n\n\ndef test_bad_step_rejected():\n with pytest.raises(ValueError):\n parse_field(MINUTE, \"*/0\")\n\n\ndef test_descending_range_rejected():\n with pytest.raises(ValueError):\n parse_field(MINUTE, \"10-1\")\n\n\ndef test_weekday_field_within_zero_to_six():\n assert parse_field(DAY_OF_WEEK, \"1-5\") == {1, 2, 3, 4, 5}\n\n\ndef test_cron_weekday_mapping():\n assert cron_weekday(datetime(2026, 3, 4)) == 3\n assert cron_weekday(datetime(2026, 3, 8)) == 0\n\n\ndef test_matches_every_minute():\n expr = CronExpression(\"* * * * *\")\n assert expr.matches(datetime(2026, 3, 4, 5, 6))\n\n\ndef test_matches_rejects_wrong_minute():\n expr = CronExpression(\"30 9 * * *\")\n assert not expr.matches(datetime(2026, 3, 4, 9, 31))\n\n\ndef test_next_after_basic():\n expr = CronExpression(\"30 9 * * *\")\n assert next_after(expr, datetime(2026, 3, 4, 5, 6)) == datetime(2026, 3, 4, 9, 30)\n\n\ndef test_next_after_is_strict():\n expr = CronExpression(\"30 9 * * *\")\n assert next_after(expr, datetime(2026, 3, 4, 9, 30)) == datetime(2026, 3, 5, 9, 30)\n\n\ndef test_next_after_rolls_to_next_day():\n expr = CronExpression(\"0 0 * * *\")\n assert next_after(expr, datetime(2026, 3, 4, 0, 0)) == datetime(2026, 3, 5, 0, 0)\n\n\ndef test_next_after_accepts_string():\n assert next_after(\"*/30 * * * *\", datetime(2026, 3, 4, 5, 6)) == datetime(2026, 3, 4, 5, 30)\n\n\ndef test_invalid_field_count():\n with pytest.raises(ValueError):\n CronExpression(\"* * * *\")\n\n\ndef test_str_roundtrip():\n assert str(CronExpression(\" 0 12 * * * \")) == \"0 12 * * *\"\n"}}}
{"instance_id": "swedl__semverlite-1", "repo": "swedl/semverlite", "base_commit": "248819bc3fd540992754e15ab48fcba834ff11d4", "patch": "diff --git a/semverlite/range.py b/semverlite/range.py\nindex abe2ece..ad1fc9e 100644\n--- a/semverlite/range.py\n+++ b/semverlite/range.py\n@@ -40,7 +40,16 @@ class VersionRange:\n raise ValueError(\"empty range\")\n self.clauses = [_parse_clause(part) for part in parts]\n \n+ def _allows_prerelease(self, version):\n+ \"\"\"A prerelease needs an explicit opt-in on the same release triple.\"\"\"\n+ for _, target in self.clauses:\n+ if target.prerelease and target.core == version.core:\n+ return True\n+ return False\n+\n def allows(self, version):\n+ if version.prerelease and not self._allows_prerelease(version):\n+ return False\n return all(self._allows_clause(op, target, version) for op, target in self.clauses)\n \n @staticmethod\ndiff --git a/semverlite/version.py b/semverlite/version.py\nindex bbb779c..4d498ed 100644\n--- a/semverlite/version.py\n+++ b/semverlite/version.py\n@@ -9,6 +9,18 @@ _VERSION_RE = re.compile(\n )\n \n \n+def _identifier_key(identifier):\n+ \"\"\"Sort key for one prerelease identifier.\n+\n+ Numeric identifiers sort numerically and below alphanumeric ones; the third\n+ element keeps keys comparable when the first two tie.\n+ \"\"\"\n+ text = str(identifier)\n+ if text.isdigit():\n+ return (0, int(text), \"\")\n+ return (1, 0, text)\n+\n+\n class Version:\n \"\"\"A semantic version: major.minor.patch[-prerelease][+build].\"\"\"\n \n@@ -43,8 +55,8 @@ class Version:\n \"\"\"Sort key implementing semver precedence (build metadata ignored).\"\"\"\n core = self.core\n if not self.prerelease:\n- return core + (1, ())\n- return core + (0, tuple(str(part) for part in self.prerelease))\n+ return core + ((1,),)\n+ return core + ((0, tuple(_identifier_key(part) for part in self.prerelease)),)\n \n def __str__(self):\n text = \"%d.%d.%d\" % self.core\n", "test_patch": "diff --git a/tests/test_prerelease_precedence.py b/tests/test_prerelease_precedence.py\nnew file mode 100644\nindex 0000000..1ba29fb\n--- /dev/null\n+++ b/tests/test_prerelease_precedence.py\n@@ -0,0 +1,55 @@\n+import pytest\n+\n+from semverlite import Version, VersionRange\n+\n+\n+def v(text):\n+ return Version.parse(text)\n+\n+\n+def test_numeric_identifiers_compare_numerically():\n+ assert v(\"1.0.0-alpha.2\") < v(\"1.0.0-alpha.10\")\n+\n+\n+def test_numeric_identifier_is_lower_than_alphanumeric():\n+ assert v(\"1.0.0-1\") < v(\"1.0.0-alpha\")\n+\n+\n+def test_total_order_matches_semver_precedence():\n+ chain = [\n+ \"1.0.0-alpha\",\n+ \"1.0.0-alpha.1\",\n+ \"1.0.0-alpha.beta\",\n+ \"1.0.0-beta\",\n+ \"1.0.0-beta.2\",\n+ \"1.0.0-beta.11\",\n+ \"1.0.0-rc.1\",\n+ \"1.0.0\",\n+ ]\n+ versions = [v(text) for text in chain]\n+ assert versions == sorted(versions)\n+ assert len(set(versions)) == len(versions)\n+\n+\n+def test_prerelease_does_not_satisfy_release_lower_bound():\n+ assert not VersionRange(\">=1.0.0\").allows(v(\"1.0.1-alpha\"))\n+\n+\n+def test_prerelease_does_not_satisfy_caret_range():\n+ assert not VersionRange(\"^1.2.3\").allows(v(\"1.3.0-beta\"))\n+\n+\n+def test_tilde_range_excludes_prerelease():\n+ assert VersionRange(\"~1.2.3\").allows(v(\"1.2.4\"))\n+ assert not VersionRange(\"~1.2.3\").allows(v(\"1.2.4-rc.1\"))\n+\n+\n+def test_range_allows_prerelease_when_same_triple_is_named():\n+ assert VersionRange(\">=1.0.0-alpha\").allows(v(\"1.0.0-beta\"))\n+ assert not VersionRange(\">=1.0.0-alpha\").allows(v(\"1.0.1-beta\"))\n+\n+\n+def test_prerelease_ordering_is_stable_across_comparisons():\n+ assert v(\"2.0.0-beta.9\") > v(\"2.0.0-beta.8\")\n+ assert v(\"2.0.0-beta.10\") > v(\"2.0.0-beta.9\")\n+ assert not v(\"2.0.0-beta.10\") < v(\"2.0.0-beta.9\")\n", "problem_statement": "Prerelease ordering is lexicographic, and prereleases leak into release ranges.\n\nTwo spec violations against semver 2.0.0:\n\n1. Prerelease identifiers are compared as strings. `1.0.0-alpha.2` sorts *after*\n `1.0.0-alpha.10` because `\"2\" > \"1\"`, and `1.0.0-beta.2` sorts after\n `1.0.0-beta.11`. Sorting a release train produces a wrong order. Numeric\n identifiers must compare numerically, a numeric identifier must sort below an\n alphanumeric one, and a shorter prerelease must sort below a longer one that\n shares its prefix.\n\n2. A prerelease satisfies ranges that never opted into prereleases.\n `VersionRange('>=1.0.0').allows(Version.parse('1.0.1-alpha'))` returns True, and\n so does `~1.2.3` with `1.2.4-rc.1`. That makes our upgrade tool offer release\n candidates as if they were final releases. A prerelease may only satisfy a range\n when some clause names a prerelease on the same `major.minor.patch` triple, so\n `>=1.0.0-alpha` does allow `1.0.0-beta` but not `1.0.1-beta`.\n\n`semverlite/version.py` holds precedence, `semverlite/range.py` holds range\nmatching; `README.md` states both rules precisely. Build metadata must stay\nignored for precedence, and equality/hashing must stay consistent with the new\nordering.", "hints_text": "", "created_at": "2026-10-30", "version": "1.0", "environment_setup_commit": "248819bc3fd540992754e15ab48fcba834ff11d4", "FAIL_TO_PASS": "[\"tests/test_prerelease_precedence.py::test_numeric_identifiers_compare_numerically\", \"tests/test_prerelease_precedence.py::test_prerelease_does_not_satisfy_caret_range\", \"tests/test_prerelease_precedence.py::test_prerelease_does_not_satisfy_release_lower_bound\", \"tests/test_prerelease_precedence.py::test_prerelease_ordering_is_stable_across_comparisons\", \"tests/test_prerelease_precedence.py::test_range_allows_prerelease_when_same_triple_is_named\", \"tests/test_prerelease_precedence.py::test_tilde_range_excludes_prerelease\", \"tests/test_prerelease_precedence.py::test_total_order_matches_semver_precedence\"]", "PASS_TO_PASS": "[\"tests/test_prerelease_precedence.py::test_numeric_identifier_is_lower_than_alphanumeric\", \"tests/test_version.py::test_caret_range\", \"tests/test_version.py::test_equality_and_hash\", \"tests/test_version.py::test_equality_ignores_build_metadata\", \"tests/test_version.py::test_exact_clause\", \"tests/test_version.py::test_inequality\", \"tests/test_version.py::test_invalid_clause_rejected\", \"tests/test_version.py::test_invalid_versions_rejected\", \"tests/test_version.py::test_ordering_by_major\", \"tests/test_version.py::test_ordering_by_minor\", \"tests/test_version.py::test_ordering_by_patch\", \"tests/test_version.py::test_parse_basic\", \"tests/test_version.py::test_parse_prerelease_and_build\", \"tests/test_version.py::test_range_lower_and_upper_bound\", \"tests/test_version.py::test_range_membership_operator\", \"tests/test_version.py::test_release_beats_prerelease\", \"tests/test_version.py::test_shorter_prerelease_is_lower\", \"tests/test_version.py::test_str_roundtrip\", \"tests/test_version.py::test_tilde_range\"]", "dockerless": {"language": "python", "python_requires": ">=3.9", "install": [], "run_from": ".", "test_cmd": "python -m pytest -v --tb=no -p no:cacheprovider {tests}", "test_files": ["tests/test_prerelease_precedence.py", "tests/test_version.py"], "files": {"README.md": "# semverlite\n\nSemantic version parsing, precedence and range matching, following\n[semver 2.0.0](https://semver.org/).\n\n## Precedence\n\n`Version` objects sort by semver precedence:\n\n1. Compare `major`, then `minor`, then `patch` numerically.\n2. A version **with** a prerelease is lower than the same version without one\n (`1.0.0-alpha < 1.0.0`).\n3. Prerelease identifiers are compared left to right. A **numeric** identifier\n always compares numerically, so `1.0.0-alpha.2 < 1.0.0-alpha.10`. An\n alphanumeric identifier compares by ASCII order and is always **greater**\n than a numeric identifier of the same position (`1.0.0-1 < 1.0.0-alpha`).\n A longer prerelease wins when all shared identifiers are equal\n (`1.0.0-alpha < 1.0.0-alpha.1`).\n4. Build metadata is ignored for precedence, so `1.0.0+a == 1.0.0+b`.\n\n## Ranges\n\n`VersionRange(text)` accepts a comma-separated conjunction of clauses using\n`=`, `==`, `>`, `>=`, `<`, `<=`, `^` and `~`. `^1.2.3` means\n`>=1.2.3, <2.0.0`; `~1.2.3` means `>=1.2.3, <1.3.0`.\n\n**Prereleases are excluded from a range unless the range itself opts in.** A\nversion carrying a prerelease satisfies the range only when some clause names a\nprerelease with the *same* `major.minor.patch` triple. So `>=1.0.0` does not\nallow `1.0.1-alpha`, while `>=1.0.0-alpha` does allow `1.0.0-beta`.\n\n## Usage\n\n```python\nfrom semverlite import Version, VersionRange\n\nVersion.parse(\"1.2.3-alpha.1\") < Version.parse(\"1.2.3\")\nVersion.parse(\"1.2.3\") in VersionRange(\">=1.0.0, <2.0.0\")\n```\n\n## Tests\n\n```\npython -m pytest -q\n```\n", "semverlite/__init__.py": "\"\"\"semverlite - semantic version parsing, precedence and ranges.\"\"\"\n\nfrom .range import VersionRange\nfrom .version import Version\n\n__version__ = \"0.5.2\"\n\n__all__ = [\"Version\", \"VersionRange\"]\n", "semverlite/range.py": "\"\"\"Version range expressions such as ``\">=1.2.3, <2.0.0\"``.\"\"\"\n\nimport re\n\nfrom .version import Version\n\n_CLAUSE_RE = re.compile(r\"^(>=|<=|==|=|>|<|\\^|~)?\\s*(\\S+)$\")\n\n\ndef _parse_clause(text):\n match = _CLAUSE_RE.match(text)\n if match is None:\n raise ValueError(\"invalid range clause: %r\" % (text,))\n operator = match.group(1) or \"==\"\n return operator, Version.parse(match.group(2))\n\n\ndef _caret_upper(target):\n \"\"\"Upper bound of ``^target``: the next release that breaks the left-most\n non-zero component.\"\"\"\n if target.major > 0:\n return Version(target.major + 1, 0, 0)\n if target.minor > 0:\n return Version(0, target.minor + 1, 0)\n return Version(0, 0, target.patch + 1)\n\n\ndef _tilde_upper(target):\n \"\"\"Upper bound of ``~target``: the next minor release.\"\"\"\n return Version(target.major, target.minor + 1, 0)\n\n\nclass VersionRange:\n \"\"\"A comma-separated list of clauses that must all hold.\"\"\"\n\n def __init__(self, text):\n self.text = text.strip()\n parts = [part.strip() for part in self.text.split(\",\") if part.strip()]\n if not parts:\n raise ValueError(\"empty range\")\n self.clauses = [_parse_clause(part) for part in parts]\n\n def allows(self, version):\n return all(self._allows_clause(op, target, version) for op, target in self.clauses)\n\n @staticmethod\n def _allows_clause(operator, target, version):\n if operator in (\"=\", \"==\"):\n return version == target\n if operator == \">\":\n return version > target\n if operator == \">=\":\n return version >= target\n if operator == \"<\":\n return version < target\n if operator == \"<=\":\n return version <= target\n if operator == \"^\":\n return target <= version < _caret_upper(target)\n if operator == \"~\":\n return target <= version < _tilde_upper(target)\n raise ValueError(\"unknown operator: %r\" % (operator,))\n\n def __contains__(self, version):\n return self.allows(version)\n\n def __str__(self):\n return self.text\n\n def __repr__(self):\n return \"VersionRange(%r)\" % (self.text,)\n", "semverlite/version.py": "\"\"\"Semantic version parsing and precedence.\"\"\"\n\nimport re\n\n_VERSION_RE = re.compile(\n r\"^(?P<major>0|[1-9]\\d*)\\.(?P<minor>0|[1-9]\\d*)\\.(?P<patch>0|[1-9]\\d*)\"\n r\"(?:-(?P<pre>[0-9A-Za-z.-]+))?\"\n r\"(?:\\+(?P<build>[0-9A-Za-z.-]+))?$\"\n)\n\n\nclass Version:\n \"\"\"A semantic version: major.minor.patch[-prerelease][+build].\"\"\"\n\n def __init__(self, major, minor, patch, prerelease=(), build=()):\n self.major = int(major)\n self.minor = int(minor)\n self.patch = int(patch)\n self.prerelease = tuple(prerelease)\n self.build = tuple(build)\n\n @classmethod\n def parse(cls, text):\n match = _VERSION_RE.match(text.strip())\n if match is None:\n raise ValueError(\"invalid version: %r\" % (text,))\n prerelease = tuple(match.group(\"pre\").split(\".\")) if match.group(\"pre\") else ()\n build = tuple(match.group(\"build\").split(\".\")) if match.group(\"build\") else ()\n return cls(\n match.group(\"major\"),\n match.group(\"minor\"),\n match.group(\"patch\"),\n prerelease,\n build,\n )\n\n @property\n def core(self):\n \"\"\"The (major, minor, patch) triple.\"\"\"\n return (self.major, self.minor, self.patch)\n\n def precedence_key(self):\n \"\"\"Sort key implementing semver precedence (build metadata ignored).\"\"\"\n core = self.core\n if not self.prerelease:\n return core + (1, ())\n return core + (0, tuple(str(part) for part in self.prerelease))\n\n def __str__(self):\n text = \"%d.%d.%d\" % self.core\n if self.prerelease:\n text += \"-\" + \".\".join(str(part) for part in self.prerelease)\n if self.build:\n text += \"+\" + \".\".join(str(part) for part in self.build)\n return text\n\n def __repr__(self):\n return \"Version(%r)\" % (str(self),)\n\n def __eq__(self, other):\n if not isinstance(other, Version):\n return NotImplemented\n return self.precedence_key() == other.precedence_key()\n\n def __ne__(self, other):\n result = self.__eq__(other)\n if result is NotImplemented:\n return result\n return not result\n\n def __lt__(self, other):\n return self.precedence_key() < other.precedence_key()\n\n def __le__(self, other):\n return self.precedence_key() <= other.precedence_key()\n\n def __gt__(self, other):\n return self.precedence_key() > other.precedence_key()\n\n def __ge__(self, other):\n return self.precedence_key() >= other.precedence_key()\n\n def __hash__(self):\n return hash(self.precedence_key())\n", "tests/test_version.py": "import pytest\n\nfrom semverlite import Version, VersionRange\n\n\ndef v(text):\n return Version.parse(text)\n\n\ndef test_parse_basic():\n version = v(\"1.2.3\")\n assert version.major == 1\n assert version.minor == 2\n assert version.patch == 3\n assert version.prerelease == ()\n assert version.build == ()\n\n\ndef test_parse_prerelease_and_build():\n version = v(\"1.2.3-rc.1+build.5\")\n assert version.prerelease == (\"rc\", \"1\")\n assert version.build == (\"build\", \"5\")\n assert version.core == (1, 2, 3)\n\n\ndef test_str_roundtrip():\n for text in (\"0.0.1\", \"1.2.3-alpha\", \"1.2.3-alpha.1+build.5\"):\n assert str(v(text)) == text\n\n\ndef test_invalid_versions_rejected():\n for text in (\"1.2\", \"1.2.3.4\", \"v1.2.3\", \"1.2.x\"):\n with pytest.raises(ValueError):\n Version.parse(text)\n\n\ndef test_ordering_by_patch():\n assert v(\"1.2.3\") < v(\"1.2.4\")\n\n\ndef test_ordering_by_minor():\n assert v(\"1.2.9\") < v(\"1.3.0\")\n\n\ndef test_ordering_by_major():\n assert v(\"1.9.9\") < v(\"2.0.0\")\n\n\ndef test_release_beats_prerelease():\n assert v(\"1.0.0-alpha\") < v(\"1.0.0\")\n assert v(\"1.0.0\") > v(\"1.0.0-rc.9\")\n\n\ndef test_shorter_prerelease_is_lower():\n assert v(\"1.0.0-alpha\") < v(\"1.0.0-alpha.1\")\n\n\ndef test_equality_ignores_build_metadata():\n assert v(\"1.0.0+a\") == v(\"1.0.0+b\")\n assert v(\"1.0.0-alpha+x\") == v(\"1.0.0-alpha+y\")\n\n\ndef test_equality_and_hash():\n assert v(\"1.2.3\") == v(\"1.2.3\")\n assert len({v(\"1.2.3\"), v(\"1.2.3\")}) == 1\n\n\ndef test_inequality():\n assert v(\"1.2.3\") != v(\"1.2.4\")\n\n\ndef test_range_lower_and_upper_bound():\n version_range = VersionRange(\">=1.0.0, <2.0.0\")\n assert version_range.allows(v(\"1.0.0\"))\n assert version_range.allows(v(\"1.5.0\"))\n assert not version_range.allows(v(\"2.0.0\"))\n assert not version_range.allows(v(\"0.9.9\"))\n\n\ndef test_range_membership_operator():\n assert v(\"1.5.0\") in VersionRange(\">=1.0.0, <2.0.0\")\n assert v(\"2.5.0\") not in VersionRange(\">=1.0.0, <2.0.0\")\n\n\ndef test_caret_range():\n version_range = VersionRange(\"^1.2.3\")\n assert version_range.allows(v(\"1.2.3\"))\n assert version_range.allows(v(\"1.9.9\"))\n assert not version_range.allows(v(\"2.0.0\"))\n assert not version_range.allows(v(\"1.2.2\"))\n\n\ndef test_tilde_range():\n version_range = VersionRange(\"~1.2.3\")\n assert version_range.allows(v(\"1.2.9\"))\n assert not version_range.allows(v(\"1.3.0\"))\n\n\ndef test_exact_clause():\n assert VersionRange(\"==1.2.3\").allows(v(\"1.2.3\"))\n assert not VersionRange(\"==1.2.3\").allows(v(\"1.2.4\"))\n\n\ndef test_invalid_clause_rejected():\n with pytest.raises(ValueError):\n VersionRange(\">=nope\")\n"}}}
|