Update app.py

app.py

@@ -1,3 +1,5 @@
+I am going to give you the script. Before modifying it, recite to me what we're updating briefly. 
+
 import os
 import time
 import json
@@ -581,112 +583,6 @@ def _create_product_all_variants_with_grid(
     return created
 
 
-def _update_product_all_variants_with_grid(
-    logs: List[str],
-    shop_id: str,
-    product_id: str,
-    all_variants: List[Dict[str, Any]],
-    enabled_ids: set,
-    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 = []
-
-    enabled_count = 0
-    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
-        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),
-        })
-
-    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:
-            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:
-                continue
-            try:
-                pwf = float(pw)
-                phf = float(phh)
-            except Exception:
-                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 ph_payload:
-            print_areas_payload.append({
-                "variant_ids": [vid_i],
-                "placeholders": ph_payload,
-            })
-
-    if not variants_payload:
-        raise RuntimeError("No variants payload could be built for update.")
-
-    _log(
-        logs,
-        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},
-        logs=logs,
-    )
-    if not isinstance(upd, dict):
-        raise RuntimeError(f"Unexpected update response: {str(upd)[:500]}")
-
-    _log(logs, f"PHASE_B_UPDATE_DONE product_id={product_id}")
-    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):
@@ -876,19 +772,8 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                 continue
 
             total_variants = len(variants_all)
-            threshold = int(CHUNK_TARGET_VARIANTS)
-
-            _log(
-                logs,
-                f"THRESHOLD_CHECK provider_id={provider_id} total_variants={total_variants} "
-                f"threshold={threshold} hard_max={HARD_MAX_VARIANTS_PER_PRODUCT}",
-            )
-            yield flush()
-
-            if total_variants <= threshold:
-                _log(logs, f"WITHIN_THRESHOLD provider_id={provider_id} total_variants={total_variants} threshold={threshold}")
-                yield flush()
 
+            if total_variants <= HARD_MAX_VARIANTS_PER_PRODUCT:
                 chunk_index = 0
                 total_chunks = 1
                 p_info_chunk = dict(product_info_full)
@@ -949,104 +834,71 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                 )
 
             else:
-                _log(logs, f"OUTSIDE_THRESHOLD provider_id={provider_id} total_variants={total_variants} threshold={threshold}")
-                yield flush()
+                total_chunks = (total_variants + CHUNK_TARGET_VARIANTS - 1) // CHUNK_TARGET_VARIANTS
+                chunk_index = 0
+                offset = 0
+                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]
 
-                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}",
+                        f"PROVIDER_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}",
                     )
                     yield flush()
-                    variants_all = variants_all[:cap]
-                    total_variants = len(variants_all)
-
-                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]
-
-                _log(
-                    logs,
-                    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_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"create_enabled={len(first_chunk)} total_variants={total_variants}",
-                )
-                yield flush()
-
-                created = _create_product_all_variants_with_grid(
-                    logs,
-                    shop_id=shop_id,
-                    blob=blob,
-                    product_info=p_info_create,
-                    upload=upload,
-                )
-                created_id = str(created.get("id") or "")
-                if not created_id:
-                    raise RuntimeError("Created product response missing id.")
-                yield flush()
 
-                enabled_set_final = set(enabled_ids_final)
+                    created = _create_product_all_variants_with_grid(
+                        logs,
+                        shop_id=shop_id,
+                        blob=blob,
+                        product_info=p_info_chunk,
+                        upload=upload,
+                    )
+                    created_id = str(created.get("id") or "")
+                    if not created_id:
+                        raise RuntimeError("Created product response missing id.")
+                    yield flush()
 
-                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()
 
-                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()
 
-                _log(
-                    logs,
-                    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 = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod1)
+                    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()
 
-                prod2 = _get_product(logs, shop_id, created_id)
-                yield flush()
+                    provider_runs.append(
+                        {
+                            "providerId": provider_id,
+                            "providerName": provider_name,
+                            "chunkIndex": chunk_index,
+                            "totalChunks": total_chunks,
+                            "catalogVariantCountTotal": total_variants,
+                            "catalogVariantCountChunk": len(chunk),
+                            "shopVariantCountAfterCreate": len(prod1.get("variants") or []),
+                            "shopVariantCountFinal": len(prod2.get("variants") or []),
+                            "productId": created_id,
+                            "priceUpdateResponse": upd,
+                        }
+                    )
 
-                provider_runs.append(
-                    {
-                        "providerId": provider_id,
-                        "providerName": provider_name,
-                        "chunkIndex": "THRESHOLD_FALLBACK",
-                        "totalChunks": 1,
-                        "catalogVariantCountTotal": total_variants,
-                        "catalogVariantCountChunk": total_variants,
-                        "shopVariantCountAfterCreate": len(prod1.get("variants") or []),
-                        "shopVariantCountFinal": len(prod2.get("variants") or []),
-                        "productId": created_id,
-                        "priceUpdateResponse": {"enableUpdate": upd_variants, "priceUpdate": upd},
-                    }
-                )
+                    offset += CHUNK_TARGET_VARIANTS
+                    chunk_index += 1
 
         result["providerRuns"] = provider_runs
         _log(logs, "PHASE_B_DONE")