simplify filter_url helpers and callers

- pass already-parsed URL through to _matches_enqueue_strategy
  (drops redundant _to_url calls per URL on the hot path)
- drop redundant parent_url param from _passes_filters; use str(parent)
- drop dead `strategy != 'all'` check in enqueue iterator (only
  reachable on non-'all' strategies after scheme passes)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: vdusek

src/crawlee/_utils/urls.py

@@ -92,10 +92,13 @@ def filter_url(
         a human-readable rejection message suitable for log output.
     """
     target_url = _to_url(target)
+
     if not _is_supported_url_scheme(target_url):
         return False, UNSUPPORTED_SCHEME_MESSAGE
-    if not _matches_enqueue_strategy(strategy, target_url=target_url, origin_url=origin):
+
+    if not _matches_enqueue_strategy(strategy, target_url=target_url, origin_url=_to_url(origin)):
         return False, f'does not match enqueue strategy {strategy!r}'
+
     return True, None
 
 
@@ -107,39 +110,28 @@ def _is_supported_url_scheme(url: str | URL) -> bool:
 def _matches_enqueue_strategy(
     strategy: EnqueueStrategy,
     *,
-    target_url: str | URL,
-    origin_url: str | URL,
+    target_url: URL,
+    origin_url: URL,
 ) -> bool:
-    """Check whether `target_url` matches `origin_url` under the given enqueue strategy.
-
-    Pure strategy comparison — does not look at the scheme. Callers should go through `filter_url`,
-    which combines this with a scheme check.
-
-    Args:
-        strategy: The enqueue strategy to apply.
-        target_url: The URL to be evaluated.
-        origin_url: The reference URL the target is compared against.
-
-    Returns:
-        `True` if `target_url` is allowed under `strategy` relative to `origin_url`, `False` otherwise.
-    """
-    target = _to_url(target_url)
-    origin = _to_url(origin_url)
-
+    """Check whether `target_url` matches `origin_url` under `strategy`. Scheme is not considered."""
     if strategy == 'all':
         return True
 
-    if origin.host is None or target.host is None:
+    if origin_url.host is None or target_url.host is None:
         return False
 
     if strategy == 'same-hostname':
-        return target.host == origin.host
+        return target_url.host == origin_url.host
 
     if strategy == 'same-domain':
-        return _domain_under_public_suffix(origin.host) == _domain_under_public_suffix(target.host)
+        return _domain_under_public_suffix(origin_url.host) == _domain_under_public_suffix(target_url.host)
 
     if strategy == 'same-origin':
-        return target.host == origin.host and target.scheme == origin.scheme and target.port == origin.port
+        return (
+            target_url.host == origin_url.host
+            and target_url.scheme == origin_url.scheme
+            and target_url.port == origin_url.port
+        )
 
     assert_never(strategy)
 

src/crawlee/crawlers/_basic/_basic_crawler.py

@@ -45,12 +45,7 @@
 from crawlee._utils.file import atomic_write, export_csv_to_stream, export_json_to_stream
 from crawlee._utils.recurring_task import RecurringTask
 from crawlee._utils.robots import RobotsTxtFile
-from crawlee._utils.urls import (
-    UNSUPPORTED_SCHEME_MESSAGE,
-    convert_to_absolute_url,
-    filter_url,
-    is_url_absolute,
-)
+from crawlee._utils.urls import UNSUPPORTED_SCHEME_MESSAGE, convert_to_absolute_url, filter_url, is_url_absolute
 from crawlee._utils.wait import wait_for
 from crawlee._utils.web import is_status_code_client_error, is_status_code_server_error
 from crawlee.errors import (
@@ -1079,14 +1074,13 @@ def _enqueue_links_filter_iterator(
 
             ok, reason = filter_url(target=parsed_target_url, strategy=strategy, origin=parsed_origin_url)
             if not ok:
-                # Strategy mismatches are expected (most extracted links are external) so they're
-                # silent. Scheme rejections and missing hostnames signal a misconfiguration upstream,
-                # so we warn — but only once per call to avoid spamming when a page yields many.
+                # Strategy mismatches are expected (most extracted links are external) so stay silent.
+                # Scheme rejections and missing hostnames signal a misconfiguration upstream, so warn.
                 if reason == UNSUPPORTED_SCHEME_MESSAGE:
                     if not scheme_warned:
                         self.log.warning(f'Skipping enqueue url {target_url!r}: {reason}')
                         scheme_warned = True
-                elif strategy != 'all' and not parsed_target_url.host and not host_warned:
+                elif not parsed_target_url.host and not host_warned:
                     self.log.warning(f'Skipping enqueue url: Missing hostname in target_url = {target_url}.')
                     host_warned = True
                 continue

src/crawlee/request_loaders/_sitemap_request_loader.py

@@ -200,11 +200,11 @@ async def _get_state(self) -> SitemapRequestLoaderState:
 
             return self._state.current_value
 
-    def _passes_filters(self, target: str, parent: URL, parent_url: str, kind: str) -> bool:
+    def _passes_filters(self, target: str, parent: URL, kind: str) -> bool:
         """Filter `target` by URL scheme and enqueue strategy, logging the reason if rejected."""
         ok, reason = filter_url(target=target, strategy=self._enqueue_strategy, origin=parent)
         if not ok:
-            logger.warning(f'Skipping {kind} {target!r} (parent {parent_url!r}): {reason}.')
+            logger.warning(f'Skipping {kind} {target!r} (parent {str(parent)!r}): {reason}.')
             return False
         return True
 
@@ -264,7 +264,7 @@ async def _load_sitemaps(self) -> None:
                     if isinstance(item, NestedSitemap):
                         # Add nested sitemap to queue
                         if item.loc not in state.pending_sitemap_urls and item.loc not in state.processed_sitemap_urls:
-                            if not self._passes_filters(item.loc, parsed_sitemap_url, sitemap_url, 'nested sitemap'):
+                            if not self._passes_filters(item.loc, parsed_sitemap_url, 'nested sitemap'):
                                 continue
                             state.pending_sitemap_urls.append(item.loc)
                         continue
@@ -282,7 +282,7 @@ async def _load_sitemaps(self) -> None:
                         if not self._check_url_patterns(url, self._include, self._exclude):
                             continue
 
-                        if not self._passes_filters(url, parsed_sitemap_url, sitemap_url, 'sitemap URL'):
+                        if not self._passes_filters(url, parsed_sitemap_url, 'sitemap URL'):
                             continue
 
                         # Check if we have capacity in the queue