Update app.py

app.py

@@ -581,6 +581,114 @@ def _create_product_all_variants_with_grid(
     return created
 
 
+def _update_product_enable_variants_with_grid(
+    logs: List[str],
+    shop_id: str,
+    product_id: str,
+    variants_to_enable: List[Dict[str, Any]],
+    upload: Dict[str, Any],
+) -> Dict[str, Any]:
+    img_id = upload.get("id")
+    img_w = float(upload.get("width") or 0)
+    img_h = float(upload.get("height") or 0)
+
+    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:
+        if not isinstance(v, dict):
+            continue
+        vid = v.get("id")
+        if vid is None:
+            continue
+        try:
+            vid_i = int(vid)
+        except Exception:
+            continue
+
+        enable_attempted += 1
+
+        placeholders = v.get("placeholders") or []
+        if not isinstance(placeholders, list) or not placeholders:
+            skipped_no_placeholders += 1
+            continue
+
+        ph_payload = []
+        for ph in placeholders:
+            if not isinstance(ph, dict):
+                continue
+            pos = ph.get("position")
+            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({
+                "position": pos,
+                "images": [{
+                    "id": img_id,
+                    "x": 0.5,
+                    "y": 0.5,
+                    "scale": scale,
+                    "angle": 0,
+                }],
+            })
+
+        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 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}"
+        )
+
+    _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}",
+    )
+
+    upd = _req(
+        "PUT",
+        f"/v1/shops/{shop_id}/products/{product_id}.json",
+        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)}")
+    return upd
+
+
 def _get_product(logs: List[str], shop_id: str, product_id: str) -> Dict[str, Any]:
     prod = _req("GET", f"/v1/shops/{shop_id}/products/{product_id}.json", logs=logs)
     if not isinstance(prod, dict):
@@ -770,8 +878,16 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                 continue
 
             total_variants = len(variants_all)
+            within_threshold = total_variants <= 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'}",
+            )
+            yield flush()
 
-            if total_variants <= HARD_MAX_VARIANTS_PER_PRODUCT:
+            if within_threshold:
                 chunk_index = 0
                 total_chunks = 1
                 p_info_chunk = dict(product_info_full)
@@ -833,51 +949,87 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
 
             else:
                 total_chunks = (total_variants + CHUNK_TARGET_VARIANTS - 1) // CHUNK_TARGET_VARIANTS
+
+                first_chunk = variants_all[0:CHUNK_TARGET_VARIANTS]
+                surplus_variants = variants_all[CHUNK_TARGET_VARIANTS:]
+
+                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)}",
+                )
+                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]
+
+                _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}",
+                )
+                yield flush()
+
+                created = _create_product_all_variants_with_grid(
+                    logs,
+                    shop_id=shop_id,
+                    blob=blob,
+                    product_info=p_info_first,
+                    upload=upload,
+                )
+                created_id = str(created.get("id") or "")
+                if not created_id:
+                    raise RuntimeError("Created product response missing id.")
+                yield flush()
+
                 chunk_index = 0
-                offset = 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": {},
+                    }
+                )
+
+                offset = CHUNK_TARGET_VARIANTS
+                chunk_index = 1
+
                 while offset < total_variants:
                     chunk = variants_all[offset: offset + CHUNK_TARGET_VARIANTS]
-                    p_info_chunk = dict(product_info_full)
-                    p_info_chunk["variants"] = chunk
-                    p_info_chunk["options"] = _rebuild_options_for_variants(chunk)
-                    p_info_chunk["_allVariants"] = variants_all
-                    p_info_chunk["_enabledVariantIds"] = [int(v.get("id")) for v in chunk if v.get("id") is not None]
+                    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_CHUNK provider_id={provider_id} name={provider_name} "
+                        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)} total_variants={total_variants}",
+                        f"offset={offset} size={len(chunk)} product_id={created_id} ids_sample={json.dumps(chunk_ids)}",
                     )
                     yield flush()
 
-                    created = _create_product_all_variants_with_grid(
+                    upd_chunk = _update_product_enable_variants_with_grid(
                         logs,
                         shop_id=shop_id,
-                        blob=blob,
-                        product_info=p_info_chunk,
+                        product_id=created_id,
+                        variants_to_enable=chunk,
                         upload=upload,
                     )
-                    created_id = str(created.get("id") or "")
-                    if not created_id:
-                        raise RuntimeError("Created product response missing id.")
-                    yield flush()
-
-                    prod1 = _get_product(logs, shop_id, created_id)
-                    yield flush()
-
-                    _log(
-                        logs,
-                        f"COMPARE_COUNTS provider={provider_id} chunk_index={chunk_index} "
-                        f"catalog_chunk={len(chunk)} "
-                        f"shop={len(prod1.get('variants') or [])}",
-                    )
-                    yield flush()
-
-                    upd = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
-                    yield flush()
-
-                    prod2 = _get_product(logs, shop_id, created_id)
                     yield flush()
 
                     provider_runs.append(
@@ -888,16 +1040,48 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                             "totalChunks": total_chunks,
                             "catalogVariantCountTotal": total_variants,
                             "catalogVariantCountChunk": len(chunk),
-                            "shopVariantCountAfterCreate": len(prod1.get("variants") or []),
-                            "shopVariantCountFinal": len(prod2.get("variants") or []),
+                            "shopVariantCountAfterCreate": 0,
+                            "shopVariantCountFinal": 0,
                             "productId": created_id,
-                            "priceUpdateResponse": upd,
+                            "priceUpdateResponse": upd_chunk,
                         }
                     )
 
                     offset += CHUNK_TARGET_VARIANTS
                     chunk_index += 1
 
+                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"shop={len(prod1.get('variants') or [])}",
+                )
+                yield flush()
+
+                upd_prices = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
+                yield flush()
+
+                prod2 = _get_product(logs, shop_id, created_id)
+                yield flush()
+
+                provider_runs.append(
+                    {
+                        "providerId": provider_id,
+                        "providerName": provider_name,
+                        "chunkIndex": "PRICE_UPDATE",
+                        "totalChunks": total_chunks,
+                        "catalogVariantCountTotal": total_variants,
+                        "catalogVariantCountChunk": 0,
+                        "shopVariantCountAfterCreate": len(prod1.get("variants") or []),
+                        "shopVariantCountFinal": len(prod2.get("variants") or []),
+                        "productId": created_id,
+                        "priceUpdateResponse": upd_prices,
+                    }
+                )
+
         result["providerRuns"] = provider_runs
         _log(logs, "PHASE_B_DONE")
         yield flush()