Update app.py

app.py

@@ -12,7 +12,9 @@ import re
 PRINTIFY_BASE = "https://api.printify.com"
 DEFAULT_BASE_PRICE = 0.001
 GRID_FILENAME = "grid.png"
-MAX_VARIANTS_PER_PRODUCT = 100
+
+HARD_MAX_VARIANTS_PER_PRODUCT = 100
+CHUNK_TARGET_VARIANTS = 85
 
 
 def _now() -> str:
@@ -615,6 +617,15 @@ def _update_prices_to_cost_plus_margin(
     return upd
 
 
+def _rebuild_options_for_variants(variants: List[Dict[str, Any]]) -> Dict[str, List[str]]:
+    colors = sorted({v.get("color") for v in variants if v.get("color")})
+    sizes = sorted({v.get("size") for v in variants if v.get("size")})
+    return {
+        "Color": colors,
+        "Size": sizes,
+    }
+
+
 def run(currency: str) -> Generator[Tuple[str, str], None, None]:
     logs: List[str] = []
     result: Dict[str, Any] = {}
@@ -705,31 +716,29 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
             )
             yield flush()
 
-            product_info = _build_product(blob, currency_code, logs)
-            _log_catalog_variants(logs, product_info, limit=75)
+            product_info_full = _build_product(blob, currency_code, logs)
+            _log_catalog_variants(logs, product_info_full, limit=75)
             yield flush()
 
-            variants_all = product_info.get("variants") or []
+            variants_all = product_info_full.get("variants") or []
             if not isinstance(variants_all, list) or not variants_all:
                 _log(logs, f"PROVIDER_SKIP provider_id={provider_id} reason=no_variants_after_build")
                 yield flush()
                 continue
 
             total_variants = len(variants_all)
-            total_chunks = (total_variants + MAX_VARIANTS_PER_PRODUCT - 1) // MAX_VARIANTS_PER_PRODUCT
 
-            chunk_index = 0
-            offset = 0
-            while offset < total_variants:
-                chunk = variants_all[offset: offset + MAX_VARIANTS_PER_PRODUCT]
-                p_info_chunk = dict(product_info)
-                p_info_chunk["variants"] = chunk
+            if total_variants <= HARD_MAX_VARIANTS_PER_PRODUCT:
+                chunk_index = 0
+                total_chunks = 1
+                p_info_chunk = dict(product_info_full)
+                p_info_chunk["variants"] = variants_all
+                p_info_chunk["options"] = _rebuild_options_for_variants(variants_all)
 
                 _log(
                     logs,
-                    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}",
+                    f"PROVIDER_SINGLE product provider_id={provider_id} name={provider_name} "
+                    f"variants={total_variants}",
                 )
                 yield flush()
 
@@ -751,7 +760,7 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                 _log(
                     logs,
                     f"COMPARE_COUNTS provider={provider_id} chunk_index={chunk_index} "
-                    f"catalog_chunk={len(chunk)} "
+                    f"catalog_chunk={len(variants_all)} "
                     f"shop={len(prod1.get('variants') or [])}",
                 )
                 yield flush()
@@ -769,7 +778,7 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                         "chunkIndex": chunk_index,
                         "totalChunks": total_chunks,
                         "catalogVariantCountTotal": total_variants,
-                        "catalogVariantCountChunk": len(chunk),
+                        "catalogVariantCountChunk": len(variants_all),
                         "shopVariantCountAfterCreate": len(prod1.get("variants") or []),
                         "shopVariantCountFinal": len(prod2.get("variants") or []),
                         "productId": created_id,
@@ -777,8 +786,70 @@ def phase_b(currency: str) -> Generator[Tuple[str, str], None, None]:
                     }
                 )
 
-                offset += MAX_VARIANTS_PER_PRODUCT
-                chunk_index += 1
+            else:
+                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)
+
+                    _log(
+                        logs,
+                        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()
+
+                    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()
+
+                    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(
+                        {
+                            "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,
+                        }
+                    )
+
+                    offset += CHUNK_TARGET_VARIANTS
+                    chunk_index += 1
 
         result["providerRuns"] = provider_runs
         _log(logs, "PHASE_B_DONE")