Merge remote-tracking branch 'origin/main' into feat/logging

# Conflicts:
#	src/osw/core.py

Author: LukasGold

CHANGELOG.md

@@ -10,6 +10,40 @@
 
 <!-- version list -->
 
+## v2.3.5 (2026-09-21)
+
+### Bug Fixes
+
+- **core**: Report dropped entities and restore the cache on error
+  ([`870adb8`](https://github.com/OpenSemanticLab/osw-python/commit/870adb876b890c8df97d6545fe2ff113940d4b5b))
+
+### Documentation
+
+- **core**: State that a failed key is not always a page title
+  ([`7297ca6`](https://github.com/OpenSemanticLab/osw-python/commit/7297ca6250292493697cbf8746b492f9a97e188e))
+
+### Testing
+
+- **core**: Cover a raise inside the load_entity page loop
+  ([`88be481`](https://github.com/OpenSemanticLab/osw-python/commit/88be4810807db103af965d9f812952875c4589c7))
+
+
+## v2.3.4 (2026-09-21)
+
+### Bug Fixes
+
+- **core**: Confirm a missing page before reporting a failed store
+  ([`5756436`](https://github.com/OpenSemanticLab/osw-python/commit/5756436e08ba95be3e177c6a78c424bfdba756c8))
+
+- **core**: Verify that store_entity actually created the page
+  ([`f84a529`](https://github.com/OpenSemanticLab/osw-python/commit/f84a5297c605fc458783e5497edeb1f97113053b))
+
+### Chores
+
+- Relicense to Apache-2.0 ([#173](https://github.com/OpenSemanticLab/osw-python/pull/173),
+  [`848615c`](https://github.com/OpenSemanticLab/osw-python/commit/848615cbd1e06401922eda88231a51028440a242))
+
+
 ## v2.3.3 (2026-09-08)
 
 ### Bug Fixes

CITATION.cff

@@ -3,7 +3,7 @@ message: "If you use this software, please cite it as below."
 type: software
 title: "OpenSemanticWorld Python Package (osw-python)"
 # Managed by python-semantic-release (version_variables). Do not edit by hand.
-version: 2.3.3
+version: 2.3.5
 abstract: "Python toolset for data processing, queries, wikicode generation and page manipulation within OpenSemanticLab: work with OpenSemanticLab instances as typed pydantic entities, query with semantic search, generate models from wiki schemas, and write changes back."
 repository-code: "https://github.com/OpenSemanticLab/osw-python"
 url: "https://opensemanticlab.github.io/osw-python/"

pyproject.toml

@@ -8,7 +8,7 @@ license-files = ["LICENSE.txt"]
 requires-python = ">=3.10,<3.14"
 # Managed by python-semantic-release (see [tool.semantic_release]). Do not
 # edit by hand; it is bumped automatically on merge to main.
-version = "2.3.3"
+version = "2.3.5"
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",

src/osw/core.py

@@ -0,0 +1,108 @@
+"""Unit tests for the cache-state restore in load_entity().
+
+Regression guard for #183: https://github.com/OpenSemanticLab/osw-python/issues/183
+load_entity() saved the original cache state before fetching pages and restored
+it afterwards, but the restore was not in a finally block. An exception raised
+while fetching or parsing a page left the cache enabled (or disabled) for the
+rest of the process instead of restoring the state the caller had before the
+call.
+
+These run fully offline: the fake site never touches the network.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+from osw.core import OSW
+
+
+class _FakeSite:
+    def __init__(self, cache_enabled, pages=None, fails=False):
+        self.cache_enabled = cache_enabled
+        self._pages = pages if pages is not None else []
+        self.fails = fails
+
+    def get_cache_enabled(self):
+        return self.cache_enabled
+
+    def enable_cache(self):
+        self.cache_enabled = True
+
+    def disable_cache(self):
+        self.cache_enabled = False
+
+    def get_page(self, param):
+        if self.fails:
+            raise RuntimeError("the wiki is not reachable")
+        return SimpleNamespace(pages=self._pages)
+
+
+@pytest.mark.parametrize("disable_cache", [False, True])
+def test_cache_stays_disabled_when_get_page_raises(disable_cache):
+    site = _FakeSite(cache_enabled=False, fails=True)
+    osw_obj = OSW.construct(site=site)
+
+    with pytest.raises(RuntimeError):
+        osw_obj.load_entity(
+            OSW.LoadEntityParam(titles=["Item:Foo"], disable_cache=disable_cache)
+        )
+
+    assert site.get_cache_enabled() is False
+
+
+@pytest.mark.parametrize("disable_cache", [False, True])
+def test_cache_stays_enabled_when_get_page_raises(disable_cache):
+    site = _FakeSite(cache_enabled=True, fails=True)
+    osw_obj = OSW.construct(site=site)
+
+    with pytest.raises(RuntimeError):
+        osw_obj.load_entity(
+            OSW.LoadEntityParam(titles=["Item:Foo"], disable_cache=disable_cache)
+        )
+
+    assert site.get_cache_enabled() is True
+
+
+class _FailingPage:
+    """A page whose slot content cannot be read.
+
+    Raises from inside the per-page loop rather than from get_page, so that the
+    try block is shown to cover the whole body and not only its first call.
+    """
+
+    title = "Item:Foo"
+
+    def get_slot_content(self, slot):
+        raise RuntimeError("the slot content is not readable")
+
+
+@pytest.mark.parametrize("cache_enabled", [False, True])
+def test_cache_is_restored_when_the_page_loop_raises(cache_enabled):
+    site = _FakeSite(cache_enabled=cache_enabled, pages=[_FailingPage()])
+    osw_obj = OSW.construct(site=site)
+
+    with pytest.raises(RuntimeError):
+        osw_obj.load_entity(
+            OSW.LoadEntityParam(titles=["Item:Foo"], disable_cache=True)
+        )
+
+    assert site.get_cache_enabled() is cache_enabled
+
+
+def test_cache_state_is_restored_after_normal_path_disabled():
+    site = _FakeSite(cache_enabled=False)
+    osw_obj = OSW.construct(site=site)
+
+    osw_obj.load_entity(OSW.LoadEntityParam(titles=["Item:Foo"]))
+
+    assert site.get_cache_enabled() is False
+
+
+def test_cache_state_is_restored_after_normal_path_enabled():
+    site = _FakeSite(cache_enabled=True)
+    osw_obj = OSW.construct(site=site)
+
+    osw_obj.load_entity(OSW.LoadEntityParam(titles=["Item:Foo"]))
+
+    assert site.get_cache_enabled() is True

tests/test_load_entity_cache_restore.py

@@ -355,6 +355,10 @@ def _stub_page_io(monkeypatch, exists: bool):
     )
     edited = []
     monkeypatch.setattr(WtPage, "edit", lambda self, *a, **k: edited.append(self.title))
+    # the write verification of store_entity() would query the wiki. These tests
+    # cover the overwrite policy, so report every edited page as existing. The
+    # verification itself is covered by test_store_entity_verify.py
+    monkeypatch.setattr(OSW, "_get_missing_page_titles", lambda self, titles: [])
     return edited
 
 

tests/test_overwrite_policy.py

@@ -26,6 +26,10 @@ def offline_osw(monkeypatch):
     monkeypatch.setattr(
         OSW, "_apply_overwrite_policy", staticmethod(lambda param: param.page)
     )
+    # the write verification would query the wiki. These tests cover the reporting
+    # of a failed edit, so report every edited page as existing. The verification
+    # itself is covered by test_store_entity_verify.py
+    monkeypatch.setattr(OSW, "_get_missing_page_titles", lambda self, titles: [])
     return OSW.construct(site=object())
 
 

tests/test_store_entity_failure.py

@@ -0,0 +1,144 @@
+"""Unit tests for store_entity() dropping entities without recording a failure.
+
+Regression guard for #183: https://github.com/OpenSemanticLab/osw-python/issues/183
+store_entity_() returned plainly (instead of raising) when it could not determine
+an entity's title or namespace. A plain return is not an exception, so the
+collector loop in store_entity() never recorded the entity in failed, and it was
+never in created_pages either: the entity was silently dropped without being
+reported to the caller. store_entity_() must now raise in both cases so the
+existing collector loop records them.
+
+These run fully offline: WtPage.init, the overwrite policy, WtPage.edit and the
+write verification are stubbed, so no network is required.
+"""
+
+import pytest
+
+import osw.core as core_mod
+import osw.model.entity as model
+from osw.core import OSW
+from osw.utils.wiki import get_namespace, get_title
+from osw.wtsite import WtPage
+
+
+def _title(entity):
+    return f"{get_namespace(entity)}:{get_title(entity)}"
+
+
+@pytest.fixture
+def offline_osw(monkeypatch):
+    # no network when a WtPage is constructed with do_init=True; mimic the
+    # do_init=False branch of WtPage.__init__ which sets .exists
+    monkeypatch.setattr(WtPage, "init", lambda self: setattr(self, "exists", False))
+    # bypass the overwrite policy: return the page that was built for the entity
+    monkeypatch.setattr(
+        OSW, "_apply_overwrite_policy", staticmethod(lambda param: param.page)
+    )
+    monkeypatch.setattr(WtPage, "edit", lambda self, *a, **kw: None)
+    # the write verification would query the wiki. These tests are not about
+    # verification, so report every edited page as existing. See
+    # tests/test_store_entity_verify.py for the write verification tests.
+    monkeypatch.setattr(OSW, "_get_missing_page_titles", lambda self, titles: [])
+    return OSW.construct(site=object())
+
+
+def test_title_failure_is_reported_serial(offline_osw, monkeypatch):
+    def _raise_get_title(entity):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(core_mod, "get_title", _raise_get_title)
+    item = model.Item(label=[model.Label(text="Solo")])
+
+    with pytest.raises(OSW.StoreEntityPartialError) as exc_info:
+        offline_osw.store_entity(OSW.StoreEntityParam(entities=[item], parallel=False))
+
+    err = exc_info.value
+    assert len(err.failed) == 1
+    (exc,) = err.failed.values()
+    assert isinstance(exc, ValueError)
+    assert "Error getting title for entity" in str(exc)
+
+
+def test_title_failure_is_reported_parallel(offline_osw, monkeypatch):
+    def _raise_get_title(entity):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(core_mod, "get_title", _raise_get_title)
+    item = model.Item(label=[model.Label(text="Solo")])
+
+    with pytest.raises(OSW.StoreEntityPartialError) as exc_info:
+        offline_osw.store_entity(OSW.StoreEntityParam(entities=[item], parallel=True))
+
+    err = exc_info.value
+    assert len(err.failed) == 1
+    (exc,) = err.failed.values()
+    assert isinstance(exc, ValueError)
+    assert "Error getting title for entity" in str(exc)
+
+
+def test_missing_namespace_is_reported(offline_osw, monkeypatch):
+    monkeypatch.setattr(core_mod, "get_namespace", lambda entity: None)
+    item = model.Item(label=[model.Label(text="NoNamespace")])
+
+    with pytest.raises(OSW.StoreEntityPartialError) as exc_info:
+        offline_osw.store_entity(OSW.StoreEntityParam(entities=[item], parallel=False))
+
+    err = exc_info.value
+    assert len(err.failed) == 1
+    (exc,) = err.failed.values()
+    assert isinstance(exc, TypeError)
+    assert "Unsupported entity type" in str(exc)
+
+
+def test_missing_title_is_reported(offline_osw, monkeypatch):
+    monkeypatch.setattr(core_mod, "get_title", lambda entity: None)
+    item = model.Item(label=[model.Label(text="NoTitle")])
+
+    with pytest.raises(OSW.StoreEntityPartialError) as exc_info:
+        offline_osw.store_entity(OSW.StoreEntityParam(entities=[item], parallel=False))
+
+    err = exc_info.value
+    assert len(err.failed) == 1
+    (exc,) = err.failed.values()
+    assert isinstance(exc, TypeError)
+    assert "Unsupported entity type" in str(exc)
+
+
+def test_only_the_failing_entity_of_a_batch_is_reported(offline_osw, monkeypatch):
+    real_get_title = get_title
+    good_item = model.Item(label=[model.Label(text="Good")])
+    bad_item = model.Item(label=[model.Label(text="Bad")])
+    good_title = _title(good_item)
+
+    # store_entity() re-validates its 'entities' param, so the object identity
+    # of good_item/bad_item is not preserved past that point. Recognize the
+    # failing entity by its label instead.
+    def _get_title(entity):
+        if entity.label and entity.label[0].text == "Bad":
+            raise RuntimeError("boom")
+        return real_get_title(entity)
+
+    monkeypatch.setattr(core_mod, "get_title", _get_title)
+
+    with pytest.raises(OSW.StoreEntityPartialError) as exc_info:
+        offline_osw.store_entity(
+            OSW.StoreEntityParam(entities=[good_item, bad_item], parallel=False)
+        )
+
+    err = exc_info.value
+    assert len(err.result.pages) == 1
+    assert len(err.failed) == 1
+    assert good_title in err.result.pages
+    assert err.stored == [good_title]
+
+
+def test_normal_path_is_unaffected(offline_osw):
+    item = model.Item(label=[model.Label(text="Fine")])
+    title = _title(item)
+
+    result = offline_osw.store_entity(
+        OSW.StoreEntityParam(entities=[item], parallel=False)
+    )
+
+    assert set(result.pages.keys()) == {title}
+    assert result.failed == {}