Update app.py

app.py

@@ -581,11 +581,12 @@ def _create_product_all_variants_with_grid(
     return created
 
 
-def _update_product_enable_variants_with_grid(
+def _update_product_all_variants_with_grid(
     logs: List[str],
     shop_id: str,
     product_id: str,
-    variants_to_enable: List[Dict[str, Any]],
+    all_variants: List[Dict[str, Any]],
+    enabled_ids: set,
     upload: Dict[str, Any],
 ) -> Dict[str, Any]:
     img_id = upload.get("id")
@@ -595,12 +596,8 @@ def _update_product_enable_variants_with_grid(
     variants_payload = []
     print_areas_payload = []
 
-    enable_attempted = 0
-    enable_ready = 0
-    skipped_no_placeholders = 0
-    skipped_bad_placeholder = 0
-
-    for v in variants_to_enable:
+    enabled_count = 0
+    for v in all_variants:
         if not isinstance(v, dict):
             continue
         vid = v.get("id")
@@ -610,12 +607,30 @@ def _update_product_enable_variants_with_grid(
             vid_i = int(vid)
         except Exception:
             continue
+        is_on = vid_i in enabled_ids
+        if is_on:
+            enabled_count += 1
+        variants_payload.append({
+            "id": vid_i,
+            "price": 1,
+            "is_enabled": bool(is_on),
+        })
 
-        enable_attempted += 1
+    for v in all_variants:
+        if not isinstance(v, dict):
+            continue
+        vid = v.get("id")
+        if vid is None:
+            continue
+        try:
+            vid_i = int(vid)
+        except Exception:
+            continue
+        if vid_i not in enabled_ids:
+            continue
 
         placeholders = v.get("placeholders") or []
         if not isinstance(placeholders, list) or not placeholders:
-            skipped_no_placeholders += 1
             continue
 
         ph_payload = []
@@ -626,13 +641,11 @@ def _update_product_enable_variants_with_grid(
             pw = ph.get("width")
             phh = ph.get("height")
             if not pos or pw is None or phh is None:
-                skipped_bad_placeholder += 1
                 continue
             try:
                 pwf = float(pw)
                 phf = float(phh)
             except Exception:
-                skipped_bad_placeholder += 1
                 continue
             scale = _scale_fill(pwf, phf, img_w, img_h)
             ph_payload.append({
@@ -646,46 +659,31 @@ def _update_product_enable_variants_with_grid(
                 }],
             })
 
-        if not ph_payload:
-            skipped_bad_placeholder += 1
-            continue
-
-        enable_ready += 1
-        variants_payload.append({
-            "id": vid_i,
-            "price": 1,
-            "is_enabled": True,
-        })
-        print_areas_payload.append({
-            "variant_ids": [vid_i],
-            "placeholders": ph_payload,
-        })
+        if ph_payload:
+            print_areas_payload.append({
+                "variant_ids": [vid_i],
+                "placeholders": ph_payload,
+            })
 
-    if not variants_payload or not print_areas_payload:
-        raise RuntimeError(
-            f"Update chunk produced no enableable variants. attempted={enable_attempted} "
-            f"ready={enable_ready} skipped_no_placeholders={skipped_no_placeholders} skipped_bad_placeholder={skipped_bad_placeholder}"
-        )
+    if not variants_payload:
+        raise RuntimeError("No variants payload could be built for update.")
 
     _log(
         logs,
-        f"PHASE_B_UPDATE product_id={product_id} enable_attempted={enable_attempted} enable_ready={enable_ready} "
-        f"print_areas_payload={len(print_areas_payload)} skipped_no_placeholders={skipped_no_placeholders} skipped_bad_placeholder={skipped_bad_placeholder}",
+        f"PHASE_B_UPDATE product_id={product_id} variants_payload_total={len(variants_payload)} "
+        f"enabled={enabled_count} print_areas_payload={len(print_areas_payload)}",
     )
 
     upd = _req(
         "PUT",
         f"/v1/shops/{shop_id}/products/{product_id}.json",
-        json_body={
-            "variants": variants_payload,
-            "print_areas": print_areas_payload,
-        },
+        json_body={"variants": variants_payload, "print_areas": print_areas_payload},
         logs=logs,
     )
     if not isinstance(upd, dict):
         raise RuntimeError(f"Unexpected update response: {str(upd)[:500]}")
 
-    _log(logs, f"PHASE_B_UPDATED product_id={product_id} enabled_in_update={len(variants_payload)}")
+    _log(logs, f"PHASE_B_UPDATE_DONE product_id={product_id}")
     return upd
 
 
@@ -878,16 +876,19 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                 continue
 
             total_variants = len(variants_all)
-            within_threshold = total_variants <= CHUNK_TARGET_VARIANTS
+            threshold = int(CHUNK_TARGET_VARIANTS)
 
             _log(
                 logs,
-                f"THRESHOLD_CHECK threshold={CHUNK_TARGET_VARIANTS} total_variants={total_variants} "
-                f"flag={'WITHIN_THRESHOLD' if within_threshold else 'OUTSIDE_THRESHOLD'}",
+                f"THRESHOLD_CHECK provider_id={provider_id} total_variants={total_variants} "
+                f"threshold={threshold} hard_max={HARD_MAX_VARIANTS_PER_PRODUCT}",
             )
             yield flush()
 
-            if within_threshold:
+            if total_variants <= threshold:
+                _log(logs, f"WITHIN_THRESHOLD provider_id={provider_id} total_variants={total_variants} threshold={threshold}")
+                yield flush()
+
                 chunk_index = 0
                 total_chunks = 1
                 p_info_chunk = dict(product_info_full)
@@ -948,32 +949,46 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                 )
 
             else:
-                total_chunks = (total_variants + CHUNK_TARGET_VARIANTS - 1) // CHUNK_TARGET_VARIANTS
+                _log(logs, f"OUTSIDE_THRESHOLD provider_id={provider_id} total_variants={total_variants} threshold={threshold}")
+                yield flush()
+
+                cap = int(HARD_MAX_VARIANTS_PER_PRODUCT)
+                if total_variants > cap:
+                    _log(
+                        logs,
+                        f"CAP_ENFORCED provider_id={provider_id} total_variants={total_variants} cap={cap} dropped={total_variants - cap}",
+                    )
+                    yield flush()
+                    variants_all = variants_all[:cap]
+                    total_variants = len(variants_all)
 
-                first_chunk = variants_all[0:CHUNK_TARGET_VARIANTS]
-                surplus_variants = variants_all[CHUNK_TARGET_VARIANTS:]
+                first_chunk = variants_all[:threshold]
+                surplus = variants_all[threshold:]
+
+                enabled_ids_create = [int(v.get("id")) for v in first_chunk if v.get("id") is not None]
+                enabled_ids_final = [int(v.get("id")) for v in variants_all if v.get("id") is not None]
 
-                surplus_ids = []
-                for v in surplus_variants[:50]:
-                    if isinstance(v, dict) and v.get("id") is not None:
-                        surplus_ids.append(v.get("id"))
                 _log(
                     logs,
-                    f"OUTSIDE_THRESHOLD_SURPLUS threshold={CHUNK_TARGET_VARIANTS} total_variants={total_variants} "
-                    f"surplus_count={len(surplus_variants)} surplus_ids_sample={json.dumps(surplus_ids)}",
+                    f"SURPLUS_COUNT provider_id={provider_id} create_enabled={len(enabled_ids_create)} "
+                    f"surplus={len(surplus)} final_enabled={len(enabled_ids_final)}",
+                )
+                _log(
+                    logs,
+                    f"SURPLUS_IDS_SAMPLE provider_id={provider_id} ids={json.dumps(enabled_ids_final[threshold:threshold+25])}",
                 )
                 yield flush()
 
-                p_info_first = dict(product_info_full)
-                p_info_first["variants"] = first_chunk
-                p_info_first["options"] = _rebuild_options_for_variants(first_chunk)
-                p_info_first["_allVariants"] = variants_all
-                p_info_first["_enabledVariantIds"] = [int(v.get("id")) for v in first_chunk if v.get("id") is not None]
+                p_info_create = dict(product_info_full)
+                p_info_create["variants"] = first_chunk
+                p_info_create["options"] = _rebuild_options_for_variants(first_chunk)
+                p_info_create["_allVariants"] = variants_all
+                p_info_create["_enabledVariantIds"] = enabled_ids_create
 
                 _log(
                     logs,
                     f"PROVIDER_CREATE_THEN_UPDATE provider_id={provider_id} name={provider_name} "
-                    f"first_chunk_size={len(first_chunk)} total_chunks={total_chunks} total_variants={total_variants}",
+                    f"create_enabled={len(first_chunk)} total_variants={total_variants}",
                 )
                 yield flush()
 
@@ -981,7 +996,7 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                     logs,
                     shop_id=shop_id,
                     blob=blob,
-                    product_info=p_info_first,
+                    product_info=p_info_create,
                     upload=upload,
                 )
                 created_id = str(created.get("id") or "")
@@ -989,79 +1004,30 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                     raise RuntimeError("Created product response missing id.")
                 yield flush()
 
-                chunk_index = 0
-                provider_runs.append(
-                    {
-                        "providerId": provider_id,
-                        "providerName": provider_name,
-                        "chunkIndex": chunk_index,
-                        "totalChunks": total_chunks,
-                        "catalogVariantCountTotal": total_variants,
-                        "catalogVariantCountChunk": len(first_chunk),
-                        "shopVariantCountAfterCreate": 0,
-                        "shopVariantCountFinal": 0,
-                        "productId": created_id,
-                        "priceUpdateResponse": {},
-                    }
-                )
+                enabled_set_final = set(enabled_ids_final)
 
-                offset = CHUNK_TARGET_VARIANTS
-                chunk_index = 1
-
-                while offset < total_variants:
-                    chunk = variants_all[offset: offset + CHUNK_TARGET_VARIANTS]
-                    chunk_ids = []
-                    for v in chunk[:50]:
-                        if isinstance(v, dict) and v.get("id") is not None:
-                            chunk_ids.append(v.get("id"))
-
-                    _log(
-                        logs,
-                        f"PROVIDER_UPDATE_CHUNK provider_id={provider_id} name={provider_name} "
-                        f"chunk_index={chunk_index} total_chunks={total_chunks} "
-                        f"offset={offset} size={len(chunk)} product_id={created_id} ids_sample={json.dumps(chunk_ids)}",
-                    )
-                    yield flush()
-
-                    upd_chunk = _update_product_enable_variants_with_grid(
-                        logs,
-                        shop_id=shop_id,
-                        product_id=created_id,
-                        variants_to_enable=chunk,
-                        upload=upload,
-                    )
-                    yield flush()
-
-                    provider_runs.append(
-                        {
-                            "providerId": provider_id,
-                            "providerName": provider_name,
-                            "chunkIndex": chunk_index,
-                            "totalChunks": total_chunks,
-                            "catalogVariantCountTotal": total_variants,
-                            "catalogVariantCountChunk": len(chunk),
-                            "shopVariantCountAfterCreate": 0,
-                            "shopVariantCountFinal": 0,
-                            "productId": created_id,
-                            "priceUpdateResponse": upd_chunk,
-                        }
-                    )
-
-                    offset += CHUNK_TARGET_VARIANTS
-                    chunk_index += 1
+                upd_variants = _update_product_all_variants_with_grid(
+                    logs,
+                    shop_id=shop_id,
+                    product_id=created_id,
+                    all_variants=variants_all,
+                    enabled_ids=enabled_set_final,
+                    upload=upload,
+                )
+                yield flush()
 
                 prod1 = _get_product(logs, shop_id, created_id)
                 yield flush()
 
                 _log(
                     logs,
-                    f"COMPARE_COUNTS provider={provider_id} chunk_index=FINAL "
-                    f"catalog_total={len(variants_all)} "
+                    f"COMPARE_COUNTS provider={provider_id} chunk_index=THRESHOLD_FALLBACK "
+                    f"catalog_chunk={total_variants} "
                     f"shop={len(prod1.get('variants') or [])}",
                 )
                 yield flush()
 
-                upd_prices = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
+                upd = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
                 yield flush()
 
                 prod2 = _get_product(logs, shop_id, created_id)
@@ -1071,14 +1037,14 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                     {
                         "providerId": provider_id,
                         "providerName": provider_name,
-                        "chunkIndex": "PRICE_UPDATE",
-                        "totalChunks": total_chunks,
+                        "chunkIndex": "THRESHOLD_FALLBACK",
+                        "totalChunks": 1,
                         "catalogVariantCountTotal": total_variants,
-                        "catalogVariantCountChunk": 0,
+                        "catalogVariantCountChunk": total_variants,
                         "shopVariantCountAfterCreate": len(prod1.get("variants") or []),
                         "shopVariantCountFinal": len(prod2.get("variants") or []),
                         "productId": created_id,
-                        "priceUpdateResponse": upd_prices,
+                        "priceUpdateResponse": {"enableUpdate": upd_variants, "priceUpdate": upd},
                     }
                 )