flowtask 5.13.2__tar.gz → 5.13.4__tar.gz

{flowtask-5.13.2 → flowtask-5.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowtask
-Version: 5.13.2
+Version: 5.13.4
 Summary: Framework for Task orchestration
 Author-email: Jesus Lara <jesuslarag@gmail.com>
 License: Apache-2.0
@@ -22,14 +22,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Framework :: AsyncIO
-Requires-Python: <3.14,>=3.11
+Requires-Python: <3.14,>=3.11.4
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: borax==3.5.0
 Requires-Dist: PyDrive==1.3.1
 Requires-Dist: chardet==5.2.0
 Requires-Dist: aiohttp-jinja2==1.6
-Requires-Dist: asyncssh[bcrypt,fido2,pkcs11,pyopenssl]==2.23.0
+Requires-Dist: asyncssh[bcrypt,fido2,pkcs11,pyopenssl]<3,>=2.24.0
 Requires-Dist: pyxlsb==1.0.10
 Requires-Dist: python-calamine==0.2.3
 Requires-Dist: pyecharts==2.0.8
@@ -46,7 +46,7 @@ Requires-Dist: adal==1.2.7
 Requires-Dist: xlrd>=2.0.2
 Requires-Dist: xmltodict<1.0.0,>=0.14.2
 Requires-Dist: zeep[async]>=4.3.3
-Requires-Dist: nltk>=3.9.3
+Requires-Dist: nltk>=3.10.3
 Requires-Dist: jdcal==1.4.1
 Requires-Dist: html5lib==1.1
 Requires-Dist: shapely>=2.1.2
@@ -70,7 +70,7 @@ Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: filetype==1.2.0
 Requires-Dist: proxylists>=0.14.0
 Requires-Dist: aioftp==0.23.1
-Requires-Dist: py7zr==0.22.0
+Requires-Dist: py7zr<2,>=1.1.3
 Requires-Dist: rarfile==4.2
 Requires-Dist: python-pptx==1.0.2
 Requires-Dist: google-auth>=2.35.0
@@ -101,7 +101,7 @@ Requires-Dist: pyheif==0.8.0
 Requires-Dist: filetype==1.2.0
 Requires-Dist: exif==1.6.1
 Requires-Dist: pillow-avif-plugin==1.5.2
-Requires-Dist: pillow-heif==0.22.0
+Requires-Dist: pillow-heif<2,>=1.3.0
 Requires-Dist: pgvector==0.4.1
 Requires-Dist: proxylists>=0.14.0
 Requires-Dist: async-notify[all]>=1.4.0

{flowtask-5.13.2 → flowtask-5.13.4}/flowtask/components/BestBuy.py

@@ -35,14 +35,17 @@ from ..interfaces.flow import FlowComponent
 from ..interfaces import HTTPService, SeleniumService
 from ..interfaces.http import ua
 from ..utils.bestbuy_greedy import (
-    NOT_ENABLED_STATES,
     CoverageMap,
     SeedCoverage,
+    SkuFulfillment,
     StoreAvailability,
     Target,
+    availability_types,
+    fulfillment_slice,
     greedy_next_seed,
     load_coverage,
     parse_fulfillment,
+    parse_sku_fulfillment,
     save_coverage,
 )
 
@@ -101,11 +104,31 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
     | storage_path               | No  | Directory for stored results and the default coverage file. Required when use_storage is true. |
     | chunk_size                 | No  | Rows per processing chunk (default 100). |
     | task_parts                 | No  | Number of task partitions (default 10). |
-    | concurrency                | No  | Max concurrent requests and sticky proxy-session pool size (default 12). |
+    | concurrency                | No  | Max concurrent requests and sticky proxy-session pool size (default 6). |
     | bulk_mode                  | No  | availability only: greedy set-cover over GraphQL nearby stores (default false = one call per row). The `enabled` column comes from the SKU button state returned with the seed call. |
     | coverage_file              | No  | Coverage map JSON (default <storage_path>/bestbuy_coverage.json; in-memory when unset). |
     | proxy_session_max_requests | No  | Requests before a sticky proxy session is rotated (default 50). |
     | proxy_session_max_age      | No  | Seconds before a sticky proxy session is rotated (default 540). |
+    | request_timeout            | No  | Hard deadline in seconds for one availability request through the proxy (default 45). |
+    | debug_payload              | No  | availability only: log the full GraphQL JSON of every call; with storage_path also dump it to <storage_path>/payloads/ (default false). |
+
+    ``type: availability`` output columns (one row per store × sku). Legacy contract:
+    ``enabled``, ``locationId``, ``location_data``, ``availability`` (pickup ``fulfillmentType``),
+    ``inStoreAvailability`` / ``inStoreAvailable`` (pickup eligible AND inventory in store),
+    ``onShelfDisplay`` (kept for compatibility; the API has no shelf-display signal, so it stays
+    ``NULL`` unless the input already carries it), ``pickupEligible``,
+    ``availablePickupQuantity``, ``availableInStoreQuantity``, ``checked``.
+    Extended columns: ``availabilityTypes`` (``IN_STORE,PICKUP,SHIPPING,DELIVERY`` summary),
+    ``condition``; pickup detail ``pickupMinHours``, ``pickupMinDate``, ``pickupMaxDate``,
+    ``pickupFulfillDate``, ``pickupDisplayDateType``, ``pickupInStoreOnly``, ``pickupPreorderable``,
+    ``pickupBackordered``, ``pickupWhenAvailable``, ``pickupRestrictions``, ``storeDistance``;
+    shipping (for the request zipcode) ``shippingEligible``, ``shippingZipcode``, ``shippingBackordered``,
+    ``shippingInStoreOnly``, ``shippingPreorderable``, ``fulfillByVendor``, ``directToBoxEligible``,
+    ``shippingSameDay``, ``shippingDefaultOption``, ``shippingFastestDate``, ``shippingFastestPrice``,
+    ``shippingFreeDate``, ``shippingOptions`` (list of dicts); home delivery ``deliveryEligible``,
+    ``deliverable``, ``deliveryBackordered``, ``deliveryInStoreOnly``, ``installationEligible``;
+    and ``fulfillment_data``, the raw JSON slice (button states, store, pickup entry, shipping,
+    delivery) the columns were derived from.
 
     :consumes: dataframe
     :produces: dataframe
@@ -118,7 +141,7 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
       brand: Epson
       bulk_mode: true
       storage_path: /home/ubuntu/symbits/bestbuy/
-      concurrency: 12
+      concurrency: 6
     ```
     """
     _version = "1.0.0"
@@ -183,19 +206,22 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
             "User-Agent": random.choice(ua),
             **self.headers
         }
-        # Cap concurrent storeAvailability requests so the Oxylabs gateway
-        # doesn't return 522 from a single residential exit IP under load.
-        # Each request rotates to a fresh sticky session, so the bottleneck
-        # is gateway capacity rather than per-IP load — 12 is safe and gives
-        # roughly 3x throughput over the original semaphore=10 (which was
-        # bottlenecked by 403s, not network capacity).
-        self.semaphore = asyncio.Semaphore(kwargs.get('concurrency', 12))
+        # Cap concurrent storeAvailability requests: under load the Oxylabs
+        # gateway fails the CONNECT tunnel with 522 (httpx.ProxyError) when
+        # sticky residential exit nodes can't reach bestbuy.com. 12 produced
+        # those 522s in production; 6 keeps the pool smaller and steadier.
+        self.semaphore = asyncio.Semaphore(kwargs.get('concurrency', 6))
         # Selenium driver is not thread-safe: serialize all execute_async_script calls
         self._selenium_semaphore = asyncio.Semaphore(1)
         # FEAT-561: sticky Oxylabs session pool (K = concurrency)
-        self._pool_size: int = kwargs.get('concurrency', 12)
+        self._pool_size: int = kwargs.get('concurrency', 6)
         self.proxy_session_max_requests: int = kwargs.get('proxy_session_max_requests', 50)
         self.proxy_session_max_age: float = kwargs.get('proxy_session_max_age', 540)
+        # Hard per-request deadline: a stalled Oxylabs CONNECT can outlive httpx's
+        # per-operation timeouts and freeze the sequential bulk seed loop.
+        self.request_timeout: float = kwargs.get('request_timeout', 45)
+        # Debug: dump the raw GraphQL availability payload (log + optional file)
+        self.debug_payload: bool = kwargs.get('debug_payload', False)
         self._session_pool: list[ProxySession] = []
         self._pool_lock = asyncio.Lock()
         self._pool_cursor: int = 0
@@ -969,11 +995,19 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
                     if attempt < 3:
                         continue
                     return None
-                r = await client.get(url, headers=api_headers)
+                r = await asyncio.wait_for(
+                    client.get(url, headers=api_headers), timeout=self.request_timeout
+                )
             except (httpx.ConnectError, httpx.ConnectTimeout, httpx.ReadTimeout,
-                    httpx.RemoteProtocolError) as ex:
+                    httpx.RemoteProtocolError, httpx.ProxyError, asyncio.TimeoutError) as ex:
+                # ProxyError: the Oxylabs CONNECT tunnel failed (e.g. "522 status code 522"
+                # when the sticky exit node can't reach bestbuy.com) — retry on a fresh session.
                 await self._release_session(session, status=None, error=ex)
                 if attempt < 3:
+                    self._logger.warning(
+                        f"GraphQL fulfillment attempt {attempt}/3 failed for sku={sku} "
+                        f"store={store_id}: {ex!r}; retrying."
+                    )
                     await asyncio.sleep(0.5 * attempt)
                     continue
                 self._logger.warning(
@@ -989,8 +1023,15 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
             await self._release_session(session, status=r.status_code)
             if r.status_code == 200:
                 self._num_iterations += 1
-                return r.json()
+                payload = r.json()
+                if self.debug_payload:
+                    await self._dump_availability_payload(payload, sku, store_id, nearby)
+                return payload
             if r.status_code in (522, 502, 503, 504) and attempt < 3:
+                self._logger.warning(
+                    f"GraphQL fulfillment attempt {attempt}/3 for sku={sku} store={store_id}: "
+                    f"HTTP {r.status_code}; retrying."
+                )
                 await asyncio.sleep(0.5 * attempt)
                 continue
             if r.status_code == 403 and attempt < 3:
@@ -1005,6 +1046,36 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
             return None
         return None
 
+    async def _dump_availability_payload(self, payload: dict, sku: str, store_id: str,
+                                         nearby: bool) -> None:
+        """Log the raw GraphQL fulfillment payload and optionally persist it to disk.
+
+        Enabled with ``debug_payload: true``. The full JSON is written to the logger
+        and, when ``storage_path`` is configured, saved as
+        ``<storage_path>/payloads/availability_<sku>_<store_id>[_nearby].json``.
+
+        Args:
+            payload: Decoded JSON returned by ``/gateway/graphql/fulfillment``.
+            sku: Product SKU of the request.
+            store_id: Seed store id of the request.
+            nearby: Whether the request asked for nearby stores (bulk mode seed call).
+        """
+        pretty = json.dumps(payload, indent=2, ensure_ascii=False, default=str)
+        self._logger.info(
+            f"BestBuy availability payload sku={sku} store={store_id} nearby={nearby}:\n{pretty}"
+        )
+        if not self.storage_path:
+            return
+        suffix = "_nearby" if nearby else ""
+        out_dir = Path(self.storage_path).joinpath("payloads")
+        out_file = out_dir.joinpath(f"availability_{sku}_{store_id}{suffix}.json")
+        try:
+            await asyncio.to_thread(out_dir.mkdir, parents=True, exist_ok=True)
+            await asyncio.to_thread(out_file.write_text, pretty, encoding="utf-8")
+            self._logger.debug(f"BestBuy: availability payload saved to {out_file}")
+        except OSError as exc:
+            self._logger.warning(f"BestBuy: could not save availability payload: {exc}")
+
     def _build_oxylabs_us_proxy_url(self, sessid: str | None = None) -> Optional[str]:
         """Build an Oxylabs Residential URL pinned to a US sticky session.
 
@@ -1187,7 +1258,8 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
             status in (403, 429)
             or (status is not None and status >= 500)
             or isinstance(error, (
-                httpx.ConnectError, httpx.ConnectTimeout, httpx.RemoteProtocolError
+                httpx.ConnectError, httpx.ConnectTimeout, httpx.RemoteProtocolError,
+                httpx.ProxyError, asyncio.TimeoutError,
             ))
         )
         if burn and not session.burned:
@@ -1254,46 +1326,150 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
             if avail is None:
                 self._write_unavailable(idx, result, sku)
                 return row
-            self._write_row(idx, avail, brand)
+            self._write_row(idx, avail, brand, parse_sku_fulfillment(result, sku))
             return row
 
+    # Extended availability columns -> default value when the column is created.
+    EXTENDED_AVAILABILITY_COLUMNS: dict[str, Any] = {
+        'availabilityTypes': None,
+        'condition': None,
+        'pickupMinHours': None,
+        'pickupMinDate': None,
+        'pickupMaxDate': None,
+        'pickupFulfillDate': None,
+        'pickupDisplayDateType': None,
+        'pickupInStoreOnly': None,
+        'pickupPreorderable': None,
+        'pickupBackordered': None,
+        'pickupWhenAvailable': None,
+        'pickupRestrictions': None,
+        'storeDistance': None,
+        'shippingEligible': None,
+        'shippingZipcode': None,
+        'shippingBackordered': None,
+        'shippingInStoreOnly': None,
+        'shippingPreorderable': None,
+        'fulfillByVendor': None,
+        'directToBoxEligible': None,
+        'shippingSameDay': None,
+        'shippingDefaultOption': None,
+        'shippingFastestDate': None,
+        'shippingFastestPrice': None,
+        'shippingFreeDate': None,
+        'shippingOptions': None,
+        'deliveryEligible': None,
+        'deliverable': None,
+        'deliveryBackordered': None,
+        'deliveryInStoreOnly': None,
+        'installationEligible': None,
+        'fulfillment_data': None,
+    }
+
+    def _ensure_extended_columns(self) -> None:
+        """Create any missing extended availability column (idempotent, object dtype)."""
+        missing = [c for c in self.EXTENDED_AVAILABILITY_COLUMNS if c not in self.data.columns]
+        for column in missing:
+            self.data[column] = pd.Series(
+                [self.EXTENDED_AVAILABILITY_COLUMNS[column]] * len(self.data),
+                index=self.data.index, dtype=object,
+            )
+
     def _write_unavailable(self, idx: Any, data: dict, sku: str) -> None:
-        """No fulfillment info in the response: write only ``enabled`` + ``checked`` (legacy behaviour)."""
-        fo = (data.get('data') or {}).get('fulfillmentOptions') or {}
-        states = fo.get('buttonStates') or []
-        state = ''
-        for bs in states:
-            if (bs.get('skuId') or bs.get('sku')) == sku:
-                state = bs.get('buttonState') or ''
-                break
-        if not state and states:
-            state = states[0].get('buttonState') or ''
-        self.data.loc[idx, 'enabled'] = state not in NOT_ENABLED_STATES
+        """No per-store pickup info in the response: write the SKU-level columns and ``checked``.
+
+        ``enabled`` still comes from the button state (legacy behaviour); shipping / delivery
+        columns and ``fulfillment_data`` are filled when the payload carries them, so a
+        ship-only SKU is still fully described.
+        """
+        info = parse_sku_fulfillment(data, sku)
+        self.data.loc[idx, 'enabled'] = info.enabled
+        self._write_sku_columns(idx, None, info)
         self.data.loc[idx, 'checked'] = True
 
-    def _write_row(self, idx: Any, avail: StoreAvailability, brand: Any) -> None:
+    def _write_sku_columns(self, idx: Any, avail: StoreAvailability | None,
+                           info: SkuFulfillment) -> None:
+        """Write the SKU-level (button state, shipping, delivery) columns plus the JSON slice.
+
+        Args:
+            idx: DataFrame index label.
+            avail: Per-store availability when known (used for the summary / JSON), else None.
+            info: SKU-level fulfillment info parsed from the same response.
+        """
+        self._ensure_extended_columns()
+        d = self.data
+        types = availability_types(avail, info)
+        d.at[idx, 'availabilityTypes'] = ','.join(types) if types else None
+        d.at[idx, 'condition'] = (avail.condition if avail and avail.condition else None) or info.condition
+        d.at[idx, 'shippingEligible'] = info.shipping_eligible
+        d.at[idx, 'shippingZipcode'] = info.shipping_zipcode
+        d.at[idx, 'shippingBackordered'] = info.shipping_backordered
+        d.at[idx, 'shippingInStoreOnly'] = info.shipping_in_store_only
+        d.at[idx, 'shippingPreorderable'] = info.shipping_preorderable
+        d.at[idx, 'fulfillByVendor'] = info.fulfill_by_vendor
+        d.at[idx, 'directToBoxEligible'] = info.direct_to_box_eligible
+        d.at[idx, 'shippingSameDay'] = info.shipping_same_day
+        d.at[idx, 'shippingDefaultOption'] = info.shipping_default_option
+        d.at[idx, 'shippingFastestDate'] = info.shipping_fastest_date
+        d.at[idx, 'shippingFastestPrice'] = info.shipping_fastest_price
+        d.at[idx, 'shippingFreeDate'] = info.shipping_free_date
+        d.at[idx, 'shippingOptions'] = (
+            [o.model_dump() for o in info.shipping_options] if info.shipping_options else None
+        )
+        d.at[idx, 'deliveryEligible'] = info.delivery_eligible
+        d.at[idx, 'deliverable'] = info.deliverable
+        d.at[idx, 'deliveryBackordered'] = info.delivery_backordered
+        d.at[idx, 'deliveryInStoreOnly'] = info.delivery_in_store_only
+        installation = [
+            x for x in (
+                avail.installation_eligible if avail else None,
+                info.shipping_installation_eligible,
+                info.delivery_installation_eligible,
+            ) if x is not None
+        ]
+        d.at[idx, 'installationEligible'] = any(installation) if installation else None
+        d.at[idx, 'fulfillment_data'] = fulfillment_slice(avail, info)
+
+    def _write_row(self, idx: Any, avail: StoreAvailability, brand: Any,
+                   info: SkuFulfillment | None = None) -> None:
         """Write the output-contract columns for one DataFrame row and set checked=True.
 
         Args:
             idx: DataFrame index label.
             avail: Normalized availability for that row's (store, sku).
             brand: Brand value to copy into the row.
+            info: SKU-level fulfillment info (button state, shipping, delivery) parsed from the
+                same response. When omitted only the per-store columns are written.
         """
         is_in_store_pickup = (
             avail.pickup_eligible and avail.instore_inventory and avail.fulfillment_type == 'PICKUP'
         )
-        self.data.loc[idx, 'enabled'] = avail.enabled
-        self.data.loc[idx, 'locationId'] = avail.store.get('storeId') or avail.store_id
-        self.data.at[idx, 'brand'] = brand
-        self.data.at[idx, 'location_data'] = avail.store
-        self.data.loc[idx, 'availability'] = avail.fulfillment_type
-        self.data.loc[idx, 'inStoreAvailability'] = is_in_store_pickup
-        self.data.loc[idx, 'inStoreAvailable'] = is_in_store_pickup
-        self.data.loc[idx, 'onShelfDisplay'] = avail.instore_inventory
-        self.data.loc[idx, 'pickupEligible'] = avail.pickup_eligible
-        self.data.loc[idx, 'availablePickupQuantity'] = avail.quantity if avail.pickup_eligible else 0
-        self.data.loc[idx, 'availableInStoreQuantity'] = avail.quantity if is_in_store_pickup else 0
-        self.data.loc[idx, 'checked'] = True
+        self._ensure_extended_columns()
+        d = self.data
+        d.loc[idx, 'enabled'] = avail.enabled
+        d.loc[idx, 'locationId'] = avail.store.get('storeId') or avail.store_id
+        d.at[idx, 'brand'] = brand
+        d.at[idx, 'location_data'] = avail.store
+        d.loc[idx, 'availability'] = avail.fulfillment_type
+        d.loc[idx, 'inStoreAvailability'] = is_in_store_pickup
+        d.loc[idx, 'inStoreAvailable'] = is_in_store_pickup
+        d.loc[idx, 'pickupEligible'] = avail.pickup_eligible
+        d.loc[idx, 'availablePickupQuantity'] = avail.quantity if avail.pickup_eligible else 0
+        d.loc[idx, 'availableInStoreQuantity'] = avail.quantity if is_in_store_pickup else 0
+        # pickup detail
+        d.at[idx, 'pickupMinHours'] = avail.min_pickup_hours
+        d.at[idx, 'pickupMinDate'] = avail.min_date
+        d.at[idx, 'pickupMaxDate'] = avail.max_date
+        d.at[idx, 'pickupFulfillDate'] = avail.fulfill_date
+        d.at[idx, 'pickupDisplayDateType'] = avail.display_date_type
+        d.at[idx, 'pickupInStoreOnly'] = avail.in_store_only
+        d.at[idx, 'pickupPreorderable'] = avail.preorderable
+        d.at[idx, 'pickupBackordered'] = avail.backordered
+        d.at[idx, 'pickupWhenAvailable'] = avail.when_available_flag
+        d.at[idx, 'pickupRestrictions'] = avail.restrictions
+        d.at[idx, 'storeDistance'] = avail.distance
+        if info is not None:
+            self._write_sku_columns(idx, avail, info)
+        d.loc[idx, 'checked'] = True
 
     def column_exists(self, column: str, default_val: Any = None):
         if column not in self.data.columns:
@@ -1501,12 +1677,13 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
         self.column_exists('locationId')
         self.column_exists('availability')
         self.column_exists('inStoreAvailability')
-        self.column_exists('onShelfDisplay', False)
+        self.column_exists('onShelfDisplay')  # not provided by the API: NULL unless set upstream
         self.column_exists('availableInStoreQuantity', 0)
         self.column_exists('inStoreAvailable', False)
         self.column_exists('pickupEligible', False)
         self.column_exists('availablePickupQuantity', 0)
         self.column_exists('enabled', False)
+        self._ensure_extended_columns()
         self.data['checked'] = False  # Add 'checked' flag column
         self._logger.info(
             f"BestBuy availability: {len(self.data)} rows, bulk_mode={self.bulk_mode}"
@@ -1557,16 +1734,25 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
             self._row_index.setdefault((sid, sku), []).append(idx)
 
         if targets and skus:
+            self._logger.info(
+                f"BestBuy bulk: {len(skus)} SKUs x {len(targets)} stores; "
+                f"resolving sku {skus[0]} (1/{len(skus)}) dynamically."
+            )
             order = await self._resolve_sku_dynamic(
                 skus[0], {t for t in targets if (t, skus[0]) in self._row_index}, targets
             )
-            for sku in skus[1:]:
+            for n, sku in enumerate(skus[1:], start=2):
+                self._logger.info(
+                    f"BestBuy bulk: sku {sku} ({n}/{len(skus)}); seeds={self._num_seeds}, "
+                    f"http_calls={self._num_iterations}."
+                )
                 uncovered = await self._resolve_sku_replay(sku, order, targets)
                 if uncovered:
                     await self._resolve_sku_dynamic(sku, uncovered, targets)
 
             # Fallback: every (store, sku) not covered by a seed response.
             leftovers = [pair for pair in self._row_index if pair not in self._seed_resolved]
+            self._logger.info(f"BestBuy bulk: {len(leftovers)} (store, sku) pairs to fallback.")
             await self._processing_tasks([self._fallback_pair(*pair) for pair in leftovers])
 
         total_pairs = len(self._row_index)
@@ -1591,11 +1777,12 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
             return
         by_store, returned, _max = parse_fulfillment(data, sku, store_id)
         avail = by_store.get(store_id) or (by_store.get(returned[0]) if returned else None)
+        info = parse_sku_fulfillment(data, sku)
         for idx in idxs:
             if avail is None:
                 self._write_unavailable(idx, data, sku)
             else:
-                self._write_row(idx, avail, self.data.at[idx, 'brand'])
+                self._write_row(idx, avail, self.data.at[idx, 'brand'], info)
 
     def _apply_response(self, sku: str, seed: str, data: dict, targets: dict[str, Target]) -> set[str]:
         """Parse one nearby response, write every covered target row, update coverage.
@@ -1604,13 +1791,14 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
             The target store ids covered by the response.
         """
         by_store, returned, max_dist = parse_fulfillment(data, sku, seed)
+        info = parse_sku_fulfillment(data, sku)
         covered: set[str] = set()
         for sid, avail in by_store.items():
             if sid not in targets:
                 continue
             idxs = self._row_index.get((sid, sku), [])
             for idx in idxs:
-                self._write_row(idx, avail, self.data.at[idx, 'brand'])
+                self._write_row(idx, avail, self.data.at[idx, 'brand'], info)
             if idxs:
                 self._seed_resolved.add((sid, sku))
             covered.add(sid)
@@ -1639,6 +1827,9 @@ class BestBuy(FlowComponent, SeleniumService, HTTPService):
                 pending -= got
                 covered |= got | {seed}
             # on failure the neighbours stay pending; the seed goes to fallback
+            self._logger.debug(
+                f"BestBuy bulk: sku={sku} seed={seed} ok={bool(data)}; {len(pending)} stores pending."
+            )
         return order
 
     async def _resolve_sku_replay(self, sku: str, seeds: list[str],