arthexis 0.1.10__py3-none-any.whl → 0.1.11__py3-none-any.whl

core/tests.py

@@ -15,7 +15,7 @@ from unittest.mock import patch
 from pathlib import Path
 import subprocess
 from glob import glob
-from datetime import timedelta
+from datetime import datetime, timedelta, timezone as datetime_timezone
 import tempfile
 from urllib.parse import quote
 
@@ -831,15 +831,21 @@ class ReleaseProcessTests(TestCase):
         )
         version_path.write_text(original, encoding="utf-8")
 
+    @mock.patch("core.views.timezone.now")
     @mock.patch("core.views.PackageRelease.dump_fixture")
     @mock.patch("core.views.release_utils.publish")
-    def test_publish_sets_pypi_url(self, publish, dump_fixture):
+    def test_publish_sets_pypi_url(self, publish, dump_fixture, now):
+        now.return_value = datetime(2025, 3, 4, 5, 6, tzinfo=datetime_timezone.utc)
         _step_publish(self.release, {}, Path("rel.log"))
         self.release.refresh_from_db()
         self.assertEqual(
             self.release.pypi_url,
             f"https://pypi.org/project/{self.package.name}/{self.release.version}/",
         )
+        self.assertEqual(
+            self.release.release_on,
+            datetime(2025, 3, 4, 5, 6, tzinfo=datetime_timezone.utc),
+        )
         dump_fixture.assert_called_once()
 
     @mock.patch("core.views.PackageRelease.dump_fixture")
@@ -849,8 +855,33 @@ class ReleaseProcessTests(TestCase):
             _step_publish(self.release, {}, Path("rel.log"))
         self.release.refresh_from_db()
         self.assertEqual(self.release.pypi_url, "")
+        self.assertIsNone(self.release.release_on)
         dump_fixture.assert_not_called()
 
+    def test_new_todo_does_not_reset_pending_flow(self):
+        user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        url = reverse("release-progress", args=[self.release.pk, "publish"])
+        Todo.objects.create(request="Initial checklist item")
+        steps = [("Confirm release TODO completion", core_views._step_check_todos)]
+        with mock.patch("core.views.PUBLISH_STEPS", steps):
+            self.client.force_login(user)
+            response = self.client.get(url)
+            self.assertTrue(response.context["has_pending_todos"])
+            self.client.get(f"{url}?ack_todos=1")
+            self.client.get(f"{url}?start=1")
+            self.client.get(f"{url}?step=0")
+            Todo.objects.create(request="Follow-up checklist item")
+            response = self.client.get(url)
+            self.assertEqual(
+                Todo.objects.filter(is_deleted=False, done_on__isnull=True).count(),
+                1,
+            )
+            self.assertIsNone(response.context["todos"])
+            self.assertFalse(response.context["has_pending_todos"])
+            session = self.client.session
+            ctx = session.get(f"release_publish_{self.release.pk}")
+            self.assertTrue(ctx.get("todos_ack"))
+
     def test_release_progress_uses_lockfile(self):
         run = []
 
@@ -1044,6 +1075,8 @@ class PackageReleaseAdminActionTests(TestCase):
         self.admin = PackageReleaseAdmin(PackageRelease, self.site)
         self.admin.message_user = lambda *args, **kwargs: None
         self.package = Package.objects.create(name="pkg")
+        self.package.is_active = True
+        self.package.save(update_fields=["is_active"])
         self.release = PackageRelease.objects.create(
             package=self.package,
             version="1.0.0",
@@ -1072,11 +1105,64 @@ class PackageReleaseAdminActionTests(TestCase):
     def test_refresh_from_pypi_creates_releases(self, mock_get, dump):
         mock_get.return_value.raise_for_status.return_value = None
         mock_get.return_value.json.return_value = {
-            "releases": {"1.0.0": [], "1.1.0": []}
+            "releases": {
+                "1.0.0": [
+                    {"upload_time_iso_8601": "2024-01-01T12:30:00.000000Z"}
+                ],
+                "1.1.0": [
+                    {"upload_time_iso_8601": "2024-02-02T15:45:00.000000Z"}
+                ],
+            }
         }
         self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
         new_release = PackageRelease.objects.get(version="1.1.0")
         self.assertEqual(new_release.revision, "")
+        self.assertEqual(
+            new_release.release_on,
+            datetime(2024, 2, 2, 15, 45, tzinfo=datetime_timezone.utc),
+        )
+        dump.assert_called_once()
+
+    @mock.patch("core.admin.PackageRelease.dump_fixture")
+    @mock.patch("core.admin.requests.get")
+    def test_refresh_from_pypi_updates_release_date(self, mock_get, dump):
+        self.release.release_on = None
+        self.release.save(update_fields=["release_on"])
+        mock_get.return_value.raise_for_status.return_value = None
+        mock_get.return_value.json.return_value = {
+            "releases": {
+                "1.0.0": [
+                    {"upload_time_iso_8601": "2024-01-01T12:30:00.000000Z"}
+                ]
+            }
+        }
+        self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
+        self.release.refresh_from_db()
+        self.assertEqual(
+            self.release.release_on,
+            datetime(2024, 1, 1, 12, 30, tzinfo=datetime_timezone.utc),
+        )
+        dump.assert_called_once()
+
+    @mock.patch("core.admin.PackageRelease.dump_fixture")
+    @mock.patch("core.admin.requests.get")
+    def test_refresh_from_pypi_restores_deleted_release(self, mock_get, dump):
+        self.release.is_deleted = True
+        self.release.save(update_fields=["is_deleted"])
+        mock_get.return_value.raise_for_status.return_value = None
+        mock_get.return_value.json.return_value = {
+            "releases": {
+                "1.0.0": [
+                    {"upload_time_iso_8601": "2024-01-01T12:30:00.000000Z"}
+                ]
+            }
+        }
+
+        self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
+
+        self.assertTrue(
+            PackageRelease.objects.filter(version="1.0.0").exists()
+        )
         dump.assert_called_once()
 
 
@@ -1300,6 +1386,22 @@ class TodoFocusViewTests(TestCase):
         change_url = reverse("admin:core_todo_change", args=[todo.pk])
         self.assertContains(resp, f'src="{change_url}"')
 
+    def test_focus_view_avoids_recursive_focus_url(self):
+        todo = Todo.objects.create(request="Task")
+        focus_url = reverse("todo-focus", args=[todo.pk])
+        Todo.objects.filter(pk=todo.pk).update(url=focus_url)
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        change_url = reverse("admin:core_todo_change", args=[todo.pk])
+        self.assertContains(resp, f'src="{change_url}"')
+
+    def test_focus_view_avoids_recursive_focus_absolute_url(self):
+        todo = Todo.objects.create(request="Task")
+        focus_url = reverse("todo-focus", args=[todo.pk])
+        Todo.objects.filter(pk=todo.pk).update(url=f"http://testserver{focus_url}")
+        resp = self.client.get(reverse("todo-focus", args=[todo.pk]))
+        change_url = reverse("admin:core_todo_change", args=[todo.pk])
+        self.assertContains(resp, f'src="{change_url}"')
+
     def test_focus_view_redirects_if_todo_completed(self):
         todo = Todo.objects.create(request="Task")
         todo.done_on = timezone.now()

core/user_data.py

@@ -238,6 +238,36 @@ def _mark_fixture_user_data(path: Path) -> None:
         model.all_objects.filter(pk=pk).update(is_user_data=True)
 
 
+def _fixture_targets_installed_apps(data) -> bool:
+    """Return ``True`` when *data* only targets installed apps and models."""
+
+    if not isinstance(data, list):
+        return True
+
+    labels = {
+        obj.get("model")
+        for obj in data
+        if isinstance(obj, dict) and obj.get("model")
+    }
+
+    for label in labels:
+        if not isinstance(label, str):
+            continue
+        if "." not in label:
+            continue
+        app_label, model_name = label.split(".", 1)
+        if not app_label or not model_name:
+            continue
+        if not apps.is_installed(app_label):
+            return False
+        try:
+            apps.get_model(label)
+        except LookupError:
+            return False
+
+    return True
+
+
 def _load_fixture(path: Path, *, mark_user_data: bool = True) -> bool:
     """Load a fixture from *path* and optionally flag loaded entities."""
 
@@ -261,9 +291,12 @@ def _load_fixture(path: Path, *, mark_user_data: bool = True) -> bool:
         except Exception:
             data = None
         else:
-            if isinstance(data, list) and not data:
-                path.unlink(missing_ok=True)
-                return False
+            if isinstance(data, list):
+                if not data:
+                    path.unlink(missing_ok=True)
+                    return False
+                if not _fixture_targets_installed_apps(data):
+                    return False
 
     try:
         call_command("loaddata", str(path), ignorenonexistent=True)
@@ -484,11 +517,23 @@ def patch_admin_user_datum() -> None:
     admin.site._user_datum_patched = True
 
 
-def _seed_data_view(request):
-    sections = []
+def _iter_entity_admin_models():
+    """Yield registered :class:`Entity` admin models without proxy duplicates."""
+
+    seen: set[type] = set()
     for model, model_admin in admin.site._registry.items():
         if not issubclass(model, Entity):
             continue
+        concrete_model = model._meta.concrete_model
+        if concrete_model in seen:
+            continue
+        seen.add(concrete_model)
+        yield model, model_admin
+
+
+def _seed_data_view(request):
+    sections = []
+    for model, model_admin in _iter_entity_admin_models():
         objs = model.objects.filter(is_seed_data=True)
         if not objs.exists():
             continue
@@ -508,9 +553,7 @@ def _seed_data_view(request):
 
 def _user_data_view(request):
     sections = []
-    for model, model_admin in admin.site._registry.items():
-        if not issubclass(model, Entity):
-            continue
+    for model, model_admin in _iter_entity_admin_models():
         objs = model.objects.filter(is_user_data=True)
         if not objs.exists():
             continue

core/views.py

@@ -11,6 +11,7 @@ from django.contrib.sites.models import Site
 from django.http import Http404, JsonResponse
 from django.shortcuts import get_object_or_404, redirect, render, resolve_url
 from django.utils import timezone
+from django.utils.text import slugify
 from django.utils.translation import gettext as _
 from django.urls import NoReverseMatch, reverse
 from django.views.decorators.csrf import csrf_exempt
@@ -18,6 +19,7 @@ from django.views.decorators.http import require_GET, require_POST
 from django.utils.http import url_has_allowed_host_and_scheme
 from pathlib import Path
 from urllib.parse import urlsplit, urlunsplit
+import errno
 import subprocess
 
 from utils import revision
@@ -81,6 +83,126 @@ def _clean_repo() -> None:
     subprocess.run(["git", "clean", "-fd"], check=False)
 
 
+def _format_path(path: Path) -> str:
+    try:
+        return str(path.resolve().relative_to(Path.cwd()))
+    except ValueError:
+        return str(path)
+
+
+def _next_patch_version(version: str) -> str:
+    from packaging.version import InvalidVersion, Version
+
+    try:
+        parsed = Version(version)
+    except InvalidVersion:
+        parts = version.split(".")
+        for index in range(len(parts) - 1, -1, -1):
+            segment = parts[index]
+            if segment.isdigit():
+                parts[index] = str(int(segment) + 1)
+                return ".".join(parts)
+        return version
+    return f"{parsed.major}.{parsed.minor}.{parsed.micro + 1}"
+
+
+def _write_todo_fixture(todo: Todo) -> Path:
+    safe_request = todo.request.replace(".", " ")
+    slug = slugify(safe_request).replace("-", "_")
+    if not slug:
+        slug = "todo"
+    path = TODO_FIXTURE_DIR / f"todos__{slug}.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = [
+        {
+            "model": "core.todo",
+            "fields": {
+                "request": todo.request,
+                "url": todo.url,
+                "request_details": todo.request_details,
+            },
+        }
+    ]
+    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    return path
+
+
+def _should_use_python_changelog(exc: OSError) -> bool:
+    winerror = getattr(exc, "winerror", None)
+    if winerror in {193}:
+        return True
+    return exc.errno in {errno.ENOEXEC, errno.EACCES, errno.ENOENT}
+
+
+def _generate_changelog_with_python(log_path: Path) -> None:
+    _append_log(log_path, "Falling back to Python changelog generator")
+    describe = subprocess.run(
+        ["git", "describe", "--tags", "--abbrev=0"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    start_tag = describe.stdout.strip() if describe.returncode == 0 else ""
+    range_spec = f"{start_tag}..HEAD" if start_tag else "HEAD"
+    log_proc = subprocess.run(
+        ["git", "log", range_spec, "--no-merges", "--pretty=format:- %h %s"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    entries = [line for line in log_proc.stdout.splitlines() if line]
+    changelog_path = Path("CHANGELOG.rst")
+    previous_lines: list[str] = []
+    if changelog_path.exists():
+        previous_lines = changelog_path.read_text(encoding="utf-8").splitlines()
+        if len(previous_lines) > 6:
+            previous_lines = previous_lines[6:]
+        else:
+            previous_lines = []
+    lines = [
+        "Changelog",
+        "=========",
+        "",
+        "Unreleased",
+        "----------",
+        "",
+    ]
+    if entries:
+        lines.extend(entries)
+    if previous_lines:
+        lines.append("")
+        lines.extend(previous_lines)
+    content = "\n".join(lines)
+    if not content.endswith("\n"):
+        content += "\n"
+    changelog_path.write_text(content, encoding="utf-8")
+    _append_log(log_path, "Regenerated CHANGELOG.rst using Python fallback")
+
+
+def _ensure_release_todo(release) -> tuple[Todo, Path]:
+    target_version = _next_patch_version(release.version)
+    request = f"Create release {release.package.name} {target_version}"
+    try:
+        url = reverse("admin:core_packagerelease_changelist")
+    except NoReverseMatch:
+        url = ""
+    todo, _ = Todo.all_objects.update_or_create(
+        request__iexact=request,
+        defaults={
+            "request": request,
+            "url": url,
+            "request_details": "",
+            "is_seed_data": True,
+            "is_deleted": False,
+            "is_user_data": False,
+            "done_on": None,
+            "on_done_condition": "",
+        },
+    )
+    fixture_path = _write_todo_fixture(todo)
+    return todo, fixture_path
+
+
 def _sync_release_with_revision(release: PackageRelease) -> tuple[bool, str]:
     """Ensure ``release`` matches the repository revision and version.
 
@@ -125,7 +247,22 @@ def _sync_release_with_revision(release: PackageRelease) -> tuple[bool, str]:
         release.save(update_fields=list(updated_fields))
         PackageRelease.dump_fixture()
 
-    return bool(updated_fields), previous_version
+    package_updated = False
+    if release.package_id and not release.package.is_active:
+        release.package.is_active = True
+        release.package.save(update_fields=["is_active"])
+        package_updated = True
+
+    version_updated = False
+    if release.version:
+        current = ""
+        if version_path.exists():
+            current = version_path.read_text(encoding="utf-8").strip()
+        if current != release.version:
+            version_path.write_text(f"{release.version}\n", encoding="utf-8")
+            version_updated = True
+
+    return bool(updated_fields or version_updated or package_updated), previous_version
 
 
 def _changelog_notes(version: str) -> str:
@@ -215,7 +352,7 @@ def _step_check_todos(release, ctx, log_path: Path) -> None:
             check=False,
         )
     ctx.pop("todos", None)
-    ctx.pop("todos_ack", None)
+    ctx["todos_ack"] = True
 
 
 def _step_check_version(release, ctx, log_path: Path) -> None:
@@ -266,6 +403,7 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
         )
         subprocess.run(["git", "add", *fixture_files], check=True)
         subprocess.run(["git", "commit", "-m", "chore: update fixtures"], check=True)
+        _append_log(log_path, "Fixture changes committed")
 
     version_path = Path("VERSION")
     if version_path.exists():
@@ -286,25 +424,59 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
             if "already on PyPI" in str(exc):
                 raise
             _append_log(log_path, f"PyPI check failed: {exc}")
+        else:
+            _append_log(
+                log_path,
+                f"Version {release.version} not published on PyPI",
+            )
     else:
         _append_log(log_path, "Network unavailable, skipping PyPI check")
 
 
 def _step_handle_migrations(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Freeze, squash and approve migrations")
+    _append_log(log_path, "Migration review acknowledged (manual step)")
 
 
 def _step_changelog_docs(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Compose CHANGELOG and documentation")
+    _append_log(log_path, "CHANGELOG and documentation review recorded")
 
 
 def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Execute pre-release actions")
+    try:
+        subprocess.run(["scripts/generate-changelog.sh"], check=True)
+    except OSError as exc:
+        if _should_use_python_changelog(exc):
+            _append_log(
+                log_path,
+                f"scripts/generate-changelog.sh failed: {exc}",
+            )
+            _generate_changelog_with_python(log_path)
+        else:  # pragma: no cover - unexpected OSError
+            raise
+    else:
+        _append_log(
+            log_path, "Regenerated CHANGELOG.rst using scripts/generate-changelog.sh"
+        )
+    subprocess.run(["git", "add", "CHANGELOG.rst"], check=True)
+    _append_log(log_path, "Staged CHANGELOG.rst for commit")
     version_path = Path("VERSION")
     version_path.write_text(f"{release.version}\n", encoding="utf-8")
+    _append_log(log_path, f"Updated VERSION file to {release.version}")
     subprocess.run(["git", "add", "VERSION"], check=True)
+    _append_log(log_path, "Staged VERSION for commit")
     diff = subprocess.run(
-        ["git", "diff", "--cached", "--quiet", "--", "VERSION"],
+        [
+            "git",
+            "diff",
+            "--cached",
+            "--quiet",
+            "--",
+            "CHANGELOG.rst",
+            "VERSION",
+        ],
         check=False,
     )
     if diff.returncode != 0:
@@ -312,13 +484,40 @@ def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
             ["git", "commit", "-m", f"pre-release commit {release.version}"],
             check=True,
         )
+        _append_log(log_path, f"Committed VERSION update for {release.version}")
     else:
-        _append_log(log_path, "No changes detected for VERSION; skipping commit")
+        _append_log(
+            log_path, "No changes detected for VERSION or CHANGELOG; skipping commit"
+        )
+        subprocess.run(["git", "reset", "HEAD", "CHANGELOG.rst"], check=False)
+        _append_log(log_path, "Unstaged CHANGELOG.rst")
         subprocess.run(["git", "reset", "HEAD", "VERSION"], check=False)
+        _append_log(log_path, "Unstaged VERSION file")
+    todo, fixture_path = _ensure_release_todo(release)
+    fixture_display = _format_path(fixture_path)
+    _append_log(log_path, f"Added TODO: {todo.request}")
+    _append_log(log_path, f"Wrote TODO fixture {fixture_display}")
+    subprocess.run(["git", "add", str(fixture_path)], check=True)
+    _append_log(log_path, f"Staged TODO fixture {fixture_display}")
+    fixture_diff = subprocess.run(
+        ["git", "diff", "--cached", "--quiet", "--", str(fixture_path)],
+        check=False,
+    )
+    if fixture_diff.returncode != 0:
+        commit_message = f"chore: add release TODO for {release.package.name}"
+        subprocess.run(["git", "commit", "-m", commit_message], check=True)
+        _append_log(log_path, f"Committed TODO fixture {fixture_display}")
+    else:
+        _append_log(
+            log_path,
+            f"No changes detected for TODO fixture {fixture_display}; skipping commit",
+        )
+    _append_log(log_path, "Pre-release actions complete")
 
 
 def _step_run_tests(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Complete test suite with --all flag")
+    _append_log(log_path, "Test suite completion acknowledged")
 
 
 def _step_promote_build(release, ctx, log_path: Path) -> None:
@@ -328,15 +527,22 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
     try:
         try:
             subprocess.run(["git", "fetch", "origin", "main"], check=True)
+            _append_log(log_path, "Fetched latest changes from origin/main")
             subprocess.run(["git", "rebase", "origin/main"], check=True)
+            _append_log(log_path, "Rebased current branch onto origin/main")
         except subprocess.CalledProcessError as exc:
             subprocess.run(["git", "rebase", "--abort"], check=False)
+            _append_log(log_path, "Rebase onto origin/main failed; aborted rebase")
             raise Exception("Rebase onto main failed") from exc
         release_utils.promote(
             package=release.to_package(),
             version=release.version,
             creds=release.to_credentials(),
         )
+        _append_log(
+            log_path,
+            f"Generated release artifacts for v{release.version}",
+        )
         from glob import glob
 
         paths = ["VERSION", *glob("core/fixtures/releases__*.json")]
@@ -347,6 +553,7 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
         )
         if diff.stdout.strip():
             subprocess.run(["git", "add", *paths], check=True)
+            _append_log(log_path, "Staged release metadata updates")
             subprocess.run(
                 [
                     "git",
@@ -356,8 +563,14 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
                 ],
                 check=True,
             )
+            _append_log(
+                log_path,
+                f"Committed release metadata for v{release.version}",
+            )
         subprocess.run(["git", "push"], check=True)
+        _append_log(log_path, "Pushed release changes to origin")
         PackageRelease.dump_fixture()
+        _append_log(log_path, "Updated release fixtures")
     except Exception:
         _clean_repo()
         raise
@@ -415,8 +628,10 @@ def _step_publish(release, ctx, log_path: Path) -> None:
     release.pypi_url = (
         f"https://pypi.org/project/{release.package.name}/{release.version}/"
     )
-    release.save(update_fields=["pypi_url"])
+    release.release_on = timezone.now()
+    release.save(update_fields=["pypi_url", "release_on"])
     PackageRelease.dump_fixture()
+    _append_log(log_path, f"Recorded PyPI URL: {release.pypi_url}")
     _append_log(log_path, "Upload complete")
 
 
@@ -644,6 +859,8 @@ def release_progress(request, pk: int, action: str):
                 f"{release.package.name}-{previous_version}*.log"
             ):
                 log_file.unlink()
+        if not release.is_current:
+            raise Http404("Release is not current")
 
     if request.GET.get("restart"):
         count = 0
@@ -656,7 +873,8 @@ def release_progress(request, pk: int, action: str):
         restart_path.write_text(str(count + 1), encoding="utf-8")
         _clean_repo()
         release.pypi_url = ""
-        release.save(update_fields=["pypi_url"])
+        release.release_on = None
+        release.save(update_fields=["pypi_url", "release_on"])
         request.session.pop(session_key, None)
         if lock_path.exists():
             lock_path.unlink()
@@ -954,9 +1172,25 @@ def _todo_iframe_url(request, todo: Todo) -> str:
     if not raw_url:
         return fallback
 
+    focus_path = reverse("todo-focus", args=[todo.pk])
+    focus_norm = focus_path.strip("/").lower()
+
+    def _is_focus_target(target: str) -> bool:
+        if not target:
+            return False
+        parsed_target = urlsplit(target)
+        path = parsed_target.path
+        if not path and not parsed_target.scheme and not parsed_target.netloc:
+            path = target.split("?", 1)[0].split("#", 1)[0]
+        normalized = path.strip("/").lower()
+        return normalized == focus_norm if normalized else False
+
+    if _is_focus_target(raw_url):
+        return fallback
+
     parsed = urlsplit(raw_url)
     if not parsed.scheme and not parsed.netloc:
-        return raw_url
+        return fallback if _is_focus_target(parsed.path) else raw_url
 
     if parsed.scheme and parsed.scheme.lower() not in {"http", "https"}:
         return fallback
@@ -996,7 +1230,10 @@ def _todo_iframe_url(request, todo: Todo) -> str:
         path = parsed.path or "/"
         if not path.startswith("/"):
             path = f"/{path}"
-        return urlunsplit(("", "", path, parsed.query, parsed.fragment)) or fallback
+        relative_url = urlunsplit(("", "", path, parsed.query, parsed.fragment))
+        if _is_focus_target(relative_url):
+            return fallback
+        return relative_url or fallback
 
     return fallback