Update app.py

app.py

@@ -528,7 +528,19 @@ def _create_product_all_variants_with_grid(
             except Exception:
                 continue
 
-    fp = _batch_fingerprint(str(shop_id), int(bp_id), int(provider_id), sorted(list(enabled_ids)))
+    all_ids_for_fp = []
+    for v in all_variants:
+        if not isinstance(v, dict):
+            continue
+        vid = v.get("id")
+        if vid is None:
+            continue
+        try:
+            all_ids_for_fp.append(int(vid))
+        except Exception:
+            continue
+
+    fp = _batch_fingerprint(str(shop_id), int(bp_id), int(provider_id), sorted(all_ids_for_fp))
 
     existing = _find_existing_product_by_fp(logs, shop_id, fp)
     if isinstance(existing, dict) and existing.get("id"):
@@ -655,6 +667,105 @@ def _create_product_all_variants_with_grid(
     return created
 
 
+def _update_product_enable_chunk_with_grid(
+    logs: List[str],
+    shop_id: str,
+    product_id: str,
+    enabled_variants: 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 = []
+
+    enabled_count = 0
+    for v in enabled_variants:
+        if not isinstance(v, dict):
+            continue
+        vid = v.get("id")
+        if vid is None:
+            continue
+        try:
+            vid_i = int(vid)
+        except Exception:
+            continue
+        enabled_count += 1
+        variants_payload.append({
+            "id": vid_i,
+            "price": 1,
+            "is_enabled": True,
+        })
+
+        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 in chunk update payload.")
+
+    if not print_areas_payload:
+        _log(logs, f"PHASE_B_UPDATE_WARN product_id={product_id} reason=no_print_areas_for_chunk enabled={enabled_count}")
+
+    payload = {
+        "variants": variants_payload,
+    }
+    if print_areas_payload:
+        payload["print_areas"] = print_areas_payload
+
+    _log(
+        logs,
+        f"PHASE_B_UPDATE product_id={product_id} enable_variants={len(variants_payload)} "
+        f"print_areas_payload={len(print_areas_payload)}",
+    )
+
+    upd = _req(
+        "PUT",
+        f"/v1/shops/{shop_id}/products/{product_id}.json",
+        json_body=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):
@@ -721,10 +832,16 @@ def _update_prices_to_cost_plus_margin(
     if not payload_variants:
         raise RuntimeError("No variant prices could be computed from costs.")
 
+    upd_body: Dict[str, Any] = {"variants": payload_variants}
+    if isinstance(product.get("title"), str):
+        upd_body["title"] = product.get("title")
+    if isinstance(product.get("description"), str):
+        upd_body["description"] = product.get("description")
+
     upd = _req(
         "PUT",
         f"/v1/shops/{shop_id}/products/{product_id}.json",
-        json_body={"variants": payload_variants},
+        json_body=upd_body,
         logs=logs,
     )
     if not isinstance(upd, dict):
@@ -909,51 +1026,86 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                 total_chunks = (total_variants + CHUNK_TARGET_VARIANTS - 1) // CHUNK_TARGET_VARIANTS
                 chunk_index = 0
                 offset = 0
+
+                first_chunk = variants_all[0:CHUNK_TARGET_VARIANTS]
+                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_CHUNK_CREATE provider_id={provider_id} name={provider_name} "
+                    f"chunk_index={chunk_index} total_chunks={total_chunks} "
+                    f"offset={0} size={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_first,
+                    upload=upload,
+                )
+                created_id = str(created.get("id") or "")
+                if not created_id:
+                    raise RuntimeError("Created product response missing id.")
+                yield flush()
+
+                prod0 = _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(first_chunk),
+                        "shopVariantCountAfterCreate": len(prod0.get("variants") or []),
+                        "shopVariantCountFinal": len(prod0.get("variants") or []),
+                        "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]
 
                     _log(
                         logs,
-                        f"PROVIDER_CHUNK provider_id={provider_id} name={provider_name} "
+                        f"PROVIDER_CHUNK_UPDATE 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)} total_variants={total_variants} product_id={created_id}",
                     )
                     yield flush()
 
-                    created = _create_product_all_variants_with_grid(
+                    upd_enable = _update_product_enable_chunk_with_grid(
                         logs,
                         shop_id=shop_id,
-                        blob=blob,
-                        product_info=p_info_chunk,
+                        product_id=created_id,
+                        enabled_variants=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)
+                    prod_u = _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 [])}",
+                        f"shop={len(prod_u.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(
                         {
                             "providerId": provider_id,
@@ -962,16 +1114,40 @@ 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": len(prod_u.get("variants") or []),
+                            "shopVariantCountFinal": len(prod_u.get("variants") or []),
                             "productId": created_id,
-                            "priceUpdateResponse": upd,
+                            "priceUpdateResponse": upd_enable,
                         }
                     )
 
                     offset += CHUNK_TARGET_VARIANTS
                     chunk_index += 1
 
+                prod_before_price = _get_product(logs, shop_id, created_id)
+                yield flush()
+
+                upd_prices = _update_prices_to_cost_plus_margin(logs, shop_id, created_id, prod_before_price)
+                yield flush()
+
+                prod_after_price = _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(prod_before_price.get("variants") or []),
+                        "shopVariantCountFinal": len(prod_after_price.get("variants") or []),
+                        "productId": created_id,
+                        "priceUpdateResponse": upd_prices,
+                    }
+                )
+
         result["providerRuns"] = provider_runs
         _log(logs, "PHASE_B_DONE")
         yield flush()