adloop 0.24.0__tar.gz → 0.26.0__tar.gz

{adloop-0.24.0 → adloop-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: adloop
-Version: 0.24.0
+Version: 0.26.0
 Summary: The AI command center for Google Ads, Reddit Ads, GA4, and tracking code.
 Keywords: mcp,google-ads,reddit-ads,google-analytics,ga4,cursor,marketing
 Author: Daniel Klose
@@ -251,12 +251,14 @@ A second ad platform, same safety model. Reddit is a separate connection: its ow
 | `get_reddit_performance` | Spend, clicks, CTR, CPC, conversions, CPA, ROAS per account/campaign/ad group/ad, optional breakdown (date, country, community, keyword, placement, …), compact mode with insights |
 | `run_reddit_report` | Raw reports endpoint for any metric (REACH, video, per-event conversions) |
 | `get_reddit_pixels` | Pixels and when each event last fired — flags ad groups optimizing for events the pixel never sent |
+| `get_reddit_audiences` | Custom and saved audiences with status, size and source, plus the ad groups that target or exclude each |
 | `search_reddit_targeting` | Communities, interests, geolocations, languages, keyword suggestions, and Reddit's related-community suggestions (by seed communities or website) |
 | `get_reddit_account_history` | Who changed what and when: field, before/after, member |
 | `estimate_reddit_ad_group` | Audience size, delivery estimate and suggested bid range for a planned ad group (Reddit's counterpart of `estimate_budget`) |
 | `pause_reddit_entity` / `enable_reddit_entity` / `remove_reddit_entity` | Status changes through the preview gate (remove = ARCHIVE, irreversible, double-confirmed) |
-| `update_reddit_campaign` / `update_reddit_ad_group` / `update_reddit_ad` | Budget, bid, run dates, weekly schedule (day names, viewer-local hours), targeting and placements (validated with Reddit at draft time), landing URL and comment changes with old → new previews, budget cap and bid-increase guards |
-| `draft_reddit_campaign` / `draft_reddit_ad_group` / `draft_reddit_ad` | Create campaign → ad group (pixel + targeting required) → post + ad, or promote an existing post with `post_id`. Everything is created **PAUSED**. |
+| `update_reddit_campaign` / `update_reddit_ad_group` / `update_reddit_ad` | Budget, bid, run dates, weekly schedule (day names, viewer-local hours), targeting, placements and audiences to target or exclude (validated with Reddit at draft time), landing URL and comment changes with old → new previews, budget cap and bid-increase guards |
+| `draft_reddit_campaign` / `draft_reddit_ad_group` / `draft_reddit_ad` | Create campaign → ad group (pixel + targeting required) → post + ad (text, image, video or a 2–6 card carousel, media by URL), or promote an existing post with `post_id`. Everything is created **PAUSED**. |
+| `draft_reddit_custom_audience` | Retargeting audiences from website visitors (pixel events) or people who engaged with your campaigns. No customer-list uploads. |
 
 > **Setup for Reddit Ads tools** — In Reddit Ads Manager open **Business Manager → Developer Application → Create app** (business admins only; no approval wait). Register the redirect URL exactly as `http://localhost:8765/callback`, then run `adloop init` and complete the Reddit Ads step: it opens Reddit's consent page (scopes `adsread` + `adsedit`, permanent grant), stores the refresh token at `~/.adloop/reddit_token.json`, and lets you pick the default ad account. Reddit rate-limits per user (reporting: 60 requests/min) and requires a descriptive User-Agent, which AdLoop builds from your app id and Reddit username. Reddit has no validate-only mode, so `confirm_and_apply(dry_run=true)` re-reads the target and re-checks the safety caps instead.
 

{adloop-0.24.0 → adloop-0.26.0}/README.md

@@ -223,12 +223,14 @@ A second ad platform, same safety model. Reddit is a separate connection: its ow
 | `get_reddit_performance` | Spend, clicks, CTR, CPC, conversions, CPA, ROAS per account/campaign/ad group/ad, optional breakdown (date, country, community, keyword, placement, …), compact mode with insights |
 | `run_reddit_report` | Raw reports endpoint for any metric (REACH, video, per-event conversions) |
 | `get_reddit_pixels` | Pixels and when each event last fired — flags ad groups optimizing for events the pixel never sent |
+| `get_reddit_audiences` | Custom and saved audiences with status, size and source, plus the ad groups that target or exclude each |
 | `search_reddit_targeting` | Communities, interests, geolocations, languages, keyword suggestions, and Reddit's related-community suggestions (by seed communities or website) |
 | `get_reddit_account_history` | Who changed what and when: field, before/after, member |
 | `estimate_reddit_ad_group` | Audience size, delivery estimate and suggested bid range for a planned ad group (Reddit's counterpart of `estimate_budget`) |
 | `pause_reddit_entity` / `enable_reddit_entity` / `remove_reddit_entity` | Status changes through the preview gate (remove = ARCHIVE, irreversible, double-confirmed) |
-| `update_reddit_campaign` / `update_reddit_ad_group` / `update_reddit_ad` | Budget, bid, run dates, weekly schedule (day names, viewer-local hours), targeting and placements (validated with Reddit at draft time), landing URL and comment changes with old → new previews, budget cap and bid-increase guards |
-| `draft_reddit_campaign` / `draft_reddit_ad_group` / `draft_reddit_ad` | Create campaign → ad group (pixel + targeting required) → post + ad, or promote an existing post with `post_id`. Everything is created **PAUSED**. |
+| `update_reddit_campaign` / `update_reddit_ad_group` / `update_reddit_ad` | Budget, bid, run dates, weekly schedule (day names, viewer-local hours), targeting, placements and audiences to target or exclude (validated with Reddit at draft time), landing URL and comment changes with old → new previews, budget cap and bid-increase guards |
+| `draft_reddit_campaign` / `draft_reddit_ad_group` / `draft_reddit_ad` | Create campaign → ad group (pixel + targeting required) → post + ad (text, image, video or a 2–6 card carousel, media by URL), or promote an existing post with `post_id`. Everything is created **PAUSED**. |
+| `draft_reddit_custom_audience` | Retargeting audiences from website visitors (pixel events) or people who engaged with your campaigns. No customer-list uploads. |
 
 > **Setup for Reddit Ads tools** — In Reddit Ads Manager open **Business Manager → Developer Application → Create app** (business admins only; no approval wait). Register the redirect URL exactly as `http://localhost:8765/callback`, then run `adloop init` and complete the Reddit Ads step: it opens Reddit's consent page (scopes `adsread` + `adsedit`, permanent grant), stores the refresh token at `~/.adloop/reddit_token.json`, and lets you pick the default ad account. Reddit rate-limits per user (reporting: 60 requests/min) and requires a descriptive User-Agent, which AdLoop builds from your app id and Reddit username. Reddit has no validate-only mode, so `confirm_and_apply(dry_run=true)` re-reads the target and re-checks the safety caps instead.
 

{adloop-0.24.0 → adloop-0.26.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "adloop"
-version = "0.24.0"
+version = "0.26.0"
 description = "The AI command center for Google Ads, Reddit Ads, GA4, and tracking code."
 readme = "README.md"
 requires-python = ">=3.11"

{adloop-0.24.0 → adloop-0.26.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "adloop"
-version = "0.24.0"
+version = "0.26.0"
 description = "The AI command center for Google Ads, Reddit Ads, GA4, and tracking code."
 readme = "README.md"
 authors = [

{adloop-0.24.0 → adloop-0.26.0}/src/adloop/ads/conversion_actions.py

@@ -26,7 +26,7 @@ import math
 import re
 import threading
 from datetime import datetime, timezone as _tz
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable
 
 from adloop.ads.enums import enum_names
 
@@ -685,13 +685,21 @@ def _gaql_escape(s: str) -> str:
     return s.replace("\\", "\\\\").replace("'", "\\'")
 
 
+# The consent values a caller may send. Google's ConsentStatus enum also has
+# UNKNOWN, but that one reports a state the API determined, not one a caller
+# declares, so it is not accepted here. Shared with the per-row columns so the
+# two cannot drift apart.
+_CONSENT_VALUES = frozenset({"GRANTED", "DENIED", "UNSPECIFIED"})
+
+
 def _consent_from_param(consent: dict | None) -> dict | None:
     """Validate + normalize the ``consent`` tool parameter.
 
     Accepts ``{"ad_user_data": "GRANTED"|"DENIED"|"UNSPECIFIED",
-    "ad_personalization": ...}``. ``UNKNOWN`` is a legal enum value too.
-    Missing keys default to UNSPECIFIED. Returns a plain dict stored in the
-    plan (JSON-safe, non-PII), or None if no consent was supplied at all.
+    "ad_personalization": ...}``. Missing keys default to UNSPECIFIED. Returns
+    a plain dict stored in the plan (JSON-safe, non-PII), or None if no consent
+    was supplied at all. ``UNKNOWN`` is refused: the enum has it, but it
+    reports what Google determined, not something a caller declares.
 
     An unknown key is an error rather than a silent no-op: ``adPersonalization``
     (camelCase) would otherwise leave the field at UNSPECIFIED, which for EEA
@@ -711,19 +719,117 @@ def _consent_from_param(consent: dict | None) -> dict | None:
             f"consent has unknown key(s): {', '.join(unknown)}. Use only "
             "ad_user_data and ad_personalization."
         )
-    valid = {"UNSPECIFIED", "UNKNOWN", "GRANTED", "DENIED"}
     out: dict[str, str] = {}
     for key in known:
         raw = str(consent.get(key, "UNSPECIFIED") or "UNSPECIFIED").upper()
-        if raw not in valid:
+        if raw not in _CONSENT_VALUES:
             raise ValueError(
                 f"consent.{key}='{raw}' is invalid. Use one of: "
-                "GRANTED, DENIED, UNSPECIFIED, UNKNOWN."
+                "GRANTED, DENIED, UNSPECIFIED."
             )
         out[key] = raw
     return out
 
 
+# Google's own template carries consent per person, not per file: Consent is a
+# field on each Conversion, so a CRM export that mixes people who opted in with
+# people who did not can say so row by row. The spelling is Google's.
+_CONSENT_HEADERS = {
+    "Ad User Data": "ad_user_data",
+    "Ad Personalization": "ad_personalization",
+}
+def _row_consent(
+    raw: list[str], optional_col: dict[str, int]
+) -> tuple[dict[str, str] | None, str]:
+    """The consent one CSV row specifies: ``(consent, problem)``.
+
+    The dict holds only the fields that row actually filled in, so the
+    file-wide ``consent`` argument stays in charge of the rest. An unusable
+    value is reported without echoing the cell — errors never carry file
+    content.
+    """
+    out: dict[str, str] = {}
+    for header, key in _CONSENT_HEADERS.items():
+        index = optional_col.get(header)
+        if index is None:
+            continue
+        value = (raw[index] or "").strip().upper()
+        if not value:
+            continue
+        if value not in _CONSENT_VALUES:
+            return None, (
+                f"{header} is not one of GRANTED, DENIED or UNSPECIFIED"
+            )
+        out[key] = value
+    return (out or None), ""
+
+
+def _effective_consent(
+    row_consent: dict | None, default: dict | None
+) -> dict | None:
+    """What one row uploads with: its own cells over the file-wide default.
+
+    Filling the remaining field with UNSPECIFIED keeps each stored row readable
+    on its own; ``_apply_consent`` would default it that way anyway.
+    """
+    if not row_consent and not default:
+        return None
+    merged = dict(default or {})
+    merged.update(row_consent or {})
+    for key in ("ad_user_data", "ad_personalization"):
+        merged.setdefault(key, "UNSPECIFIED")
+    return merged
+
+
+def _consent_summary(
+    rows: list[dict], default: dict | None
+) -> dict[str, dict[str, int]]:
+    """How many uploaded rows carry each consent value, per field.
+
+    The preview is where an upload gets approved, and the plan-level ``consent``
+    is only the fallback for rows without their own: a file whose rows say
+    DENIED must not preview as GRANTED because that is the argument.
+    """
+    summary: dict[str, dict[str, int]] = {
+        "ad_user_data": {}, "ad_personalization": {},
+    }
+    for row in rows:
+        values = _effective_consent(row.get("consent"), default) or {}
+        for key in summary:
+            value = values.get(key, "UNSPECIFIED")
+            summary[key][value] = summary[key].get(value, 0) + 1
+    return summary
+
+
+def _consent_warnings(
+    rows: list[dict], *, columns_present: bool, default: dict | None
+) -> list[str]:
+    """Rows that end up UNSPECIFIED even though the file tried to carry consent.
+
+    Google uses UNSPECIFIED conversions only in a limited way for EEA traffic,
+    and empty consent cells still look like the file says something. A file
+    without consent columns stays quiet: that is today's behaviour, and a
+    warning on every such file would only train callers to ignore it.
+    """
+    if not columns_present:
+        return []
+    unspecified = 0
+    for row in rows:
+        values = _effective_consent(row.get("consent"), default) or {}
+        if any(
+            values.get(key, "UNSPECIFIED") == "UNSPECIFIED"
+            for key in ("ad_user_data", "ad_personalization")
+        ):
+            unspecified += 1
+    if not unspecified:
+        return []
+    return [
+        f"{unspecified} of {len(rows)} row(s) upload as UNSPECIFIED for "
+        "consent: their consent cells are empty or only partly filled. Google "
+        "uses UNSPECIFIED conversions only in a limited way for EEA traffic."
+    ]
+
+
 def _apply_consent(client: object, conversion: object, consent: dict | None) -> None:
     """Set conversion.consent.{ad_user_data,ad_personalization} from a plan dict.
 
@@ -1032,6 +1138,24 @@ def _short_row(raw: list[str], col: dict[str, int]) -> bool:
     return len(raw) <= max(col.values())
 
 
+def _optional_column_indexes(
+    header: list[str], names: list[str]
+) -> dict[str, int]:
+    """Indexes of optional columns, matched case-insensitively.
+
+    The required columns come from Google's template verbatim. Optional ones
+    are typed by hand into exports often enough that "Order ID" versus
+    "order id" should not decide whether the file has a dedup key.
+    """
+    folded = [cell.casefold() for cell in header]
+    found: dict[str, int] = {}
+    for name in names:
+        key = name.casefold()
+        if key in folded:
+            found[name] = folded.index(key)
+    return found
+
+
 def _pad_to_header(raw: list[str], columns: int) -> list[str]:
     """Fill missing trailing cells with "" so every header index exists."""
     if len(raw) >= columns:
@@ -1067,6 +1191,9 @@ def _parse_call_conversion_csv(
     col, errors = _column_map(header, _EXPECTED_CALL_HEADERS)
     if errors:
         return [], errors, [], []
+    optional_col = _optional_column_indexes(
+        [cell.strip() for cell in header], list(_CONSENT_HEADERS)
+    )
 
     now = datetime.now(_tz.utc)
     out: list[dict] = []
@@ -1083,6 +1210,10 @@ def _parse_call_conversion_csv(
             })
             continue
         raw = _pad_to_header(raw, len(header))
+        row_consent, problem = _row_consent(raw, optional_col)
+        if problem:
+            skipped.append({"row": source_line, "reason": problem})
+            continue
         value, currency, problem = _parse_amount(
             raw[col["Conversion Value"]], raw[col["Conversion Currency"]]
         )
@@ -1137,6 +1268,8 @@ def _parse_call_conversion_csv(
             "conversion_time": converted,
             "conversion_value": value,
             "currency_code": currency,
+            "consent": row_consent,
+            "consent_columns_present": bool(optional_col),
         })
     return out, errors, advisories, skipped
 
@@ -1203,7 +1336,9 @@ def draft_upload_call_conversions(
     ``consent`` (GDPR/EEA): a dict like
     ``{"ad_user_data": "GRANTED", "ad_personalization": "DENIED"}``. Values:
     GRANTED / DENIED / UNSPECIFIED. Required for EEA traffic. Defaults to
-    UNSPECIFIED when omitted.
+    UNSPECIFIED when omitted. Optional ``Ad User Data`` /
+    ``Ad Personalization`` CSV columns say it per row and override this value
+    for the row that fills them in.
 
     PII note: the caller phone number is required raw by Google for matching,
     so the rows live in the plan's ``apply_only_payload`` — apply needs them,
@@ -1257,6 +1392,12 @@ def draft_upload_call_conversions(
         }
     rows = usable
 
+    consent_warnings = _consent_warnings(
+        rows,
+        columns_present=any(r.get("consent_columns_present") for r in rows),
+        default=consent_norm,
+    )
+    dedup_warnings = _duplicate_row_warnings(rows, _call_duplicate_key, "call")
     distinct_actions = sorted({r["conversion_name"] for r in rows})
     total_value, totals_by_currency, currency_hint, value_warnings = (
         _value_summary(rows)
@@ -1293,6 +1434,7 @@ def draft_upload_call_conversions(
             "conversion_time": r["conversion_time"],
             "conversion_value": r["conversion_value"],
             "currency_code": r["currency_code"],
+            "consent": _effective_consent(r.get("consent"), consent_norm),
         }
         for r in rows
     ]
@@ -1329,7 +1471,11 @@ def draft_upload_call_conversions(
             # Resolved at draft time; apply reads them instead of querying again.
             "conversion_actions": action_resources,
             "consent": consent_norm,
-            "parse_warnings": parse_advisories,
+            # What the rows actually upload with; ``consent`` alone is only the
+            # fallback and would misrepresent a file that sets it per row.
+            "consent_summary": _consent_summary(rows, consent_norm),
+            "parse_warnings": [*parse_advisories, *consent_warnings],
+            "dedup_warnings": dedup_warnings,
             # Display sample uses REDACTED caller ids only.
             "sample_rows": [
                 {
@@ -1337,6 +1483,7 @@ def draft_upload_call_conversions(
                     "call_start_time": r["call_start_time"],
                     "conversion_name": r["conversion_name"],
                     "conversion_value": r["conversion_value"],
+                    "consent": _effective_consent(r.get("consent"), consent_norm),
                 }
                 for r in rows[:3]
             ],
@@ -1461,6 +1608,106 @@ def _value_summary(
     return total, by_currency, hint, warnings
 
 
+def _join_source_lines(lines: list[object]) -> str:
+    """``4``, ``4 and 9``, ``4, 9 and 12`` — in reading order."""
+
+    def order(line: object) -> tuple:
+        # Line numbers are ints; a hand-built plan may carry none. Sorting the
+        # mixed list by ``str`` alone would put line 10 in front of line 9.
+        return (0, line, "") if isinstance(line, int) else (1, 0, str(line))
+
+    parts = [str(line) for line in sorted(lines, key=order)]
+    if len(parts) == 1:
+        return parts[0]
+    return f"{', '.join(parts[:-1])} and {parts[-1]}"
+
+
+def _duplicate_row_warnings(
+    rows: list[dict],
+    key_of: Callable[[dict], tuple | None],
+    what: str,
+    order_id_of: Callable[[dict], str] | None = None,
+) -> list[str]:
+    """Rows that repeat inside one CSV — reported, not refused.
+
+    Google dedups a re-upload on the Order ID, and a call upload has no dedup
+    key at all, so the same record twice in one file goes out twice and nothing
+    in the result says so. Legitimate repetition exists (two calls from the
+    same number, the same second), so the rows are named and the caller decides
+    in the preview.
+
+    ``order_id_of`` splits the wording: rows that share an Order ID collapse
+    into one conversion at Google, the others add up.
+    """
+    seen: dict[tuple, list[tuple[object, dict]]] = {}
+    for index, row in enumerate(rows, start=1):
+        key = key_of(row)
+        if key:
+            seen.setdefault(key, []).append((_source_line(row, index), row))
+    warnings: list[str] = []
+    for group in seen.values():
+        if len(group) < 2:
+            continue
+        lines = [line for line, _ in group]
+        order_id = order_id_of(group[0][1]) if order_id_of else ""
+        if order_id:
+            warnings.append(
+                f"{len(group)} rows look like the same {what} and carry the "
+                f"same Order ID: lines {_join_source_lines(lines)}. Google "
+                "dedups on the conversion action and that Order ID, so they "
+                "count once."
+            )
+            continue
+        warnings.append(
+            f"{len(group)} rows look like the same {what}: lines "
+            f"{_join_source_lines(lines)}. Every row is uploaded as its own "
+            f"conversion, so the record is counted {len(group)} times — delete "
+            "the extra rows if it is one copy-paste accident."
+        )
+    return warnings
+
+
+def _call_duplicate_key(row: dict) -> tuple | None:
+    """What identifies a call: the number and the start of the call.
+
+    The value stays out of the key on purpose: two rows for the same call with
+    different values are still almost certainly one call exported twice.
+    """
+    caller = row.get("caller_id") or ""
+    if not caller:
+        return None
+    return (caller, row.get("call_start_time") or "")
+
+
+def _ec_duplicate_key(row: dict) -> tuple | None:
+    """What identifies a lead: the strongest identifier the row carries.
+
+    A row that only matched on its address is compared by that address, not
+    reported as a duplicate of every other row without an email. The Order ID
+    is part of the key whenever the row has one: two orders for the same lead
+    at the same (often date-only) time are two real orders, not one.
+    """
+    identifier: object = row.get("email_sha256") or row.get("phone_sha256")
+    if not identifier and _has_complete_address(row):
+        identifier = (
+            row["first_name_sha256"],
+            row["last_name_sha256"],
+            row["country_code"],
+            row["postal_code"],
+        )
+    if not identifier:
+        return None
+    return (
+        identifier,
+        row.get("conversion_time") or "",
+        row.get("order_id") or "",
+    )
+
+
+def _row_order_id(row: dict) -> str:
+    return str(row.get("order_id") or "")
+
+
 def _upload_draft_preflight(
     config: AdLoopConfig,
     *,
@@ -1954,7 +2201,10 @@ def _apply_upload_call_conversions(
                 cc.conversion_value = float(r["conversion_value"])
             if r.get("currency_code"):
                 cc.currency_code = r["currency_code"]
-            _apply_consent(client, cc, consent)
+            # The row's own value wins; the file-wide argument is the fallback
+            # for rows that left the consent columns empty (and for plans
+            # drafted before the columns existed).
+            _apply_consent(client, cc, r.get("consent") or consent)
             payload.append(cc)
         return payload
 
@@ -2020,8 +2270,10 @@ def _parse_ec_for_leads_csv(
     Conversion Name, Conversion Time, Conversion Value, Conversion Currency.
     Optional: Order ID (Google's dedup key — strongly recommended so
     re-uploads of the same source row don't double-count), Country Code,
-    Postal Code. Returns ``(rows, errors, advisories, skipped)``: ``errors``
-    are file-level problems, ``advisories`` describe rows that still upload, and
+    Postal Code, and Google's per-person consent columns ``Ad User Data`` /
+    ``Ad Personalization``. Returns ``(rows, errors, advisories, skipped)``:
+    ``errors`` are file-level problems, ``advisories`` describe rows that still
+    upload, and
     ``skipped`` lists every row that will not be uploaded with its
     ``source_line``. A record that ends before the last required column is
     skipped instead of aborting the draft.
@@ -2041,7 +2293,9 @@ def _parse_ec_for_leads_csv(
     if errors:
         return [], errors, [], []
     header = [cell.strip() for cell in raw_header]
-    optional_col = {n: header.index(n) for n in _OPTIONAL_EC_HEADERS if n in header}
+    optional_col = _optional_column_indexes(
+        header, [*_OPTIONAL_EC_HEADERS, *_CONSENT_HEADERS]
+    )
 
     out: list[dict] = []
     skipped: list[dict] = []
@@ -2060,6 +2314,10 @@ def _parse_ec_for_leads_csv(
         # the header promises exists (Country Code and Postal Code used to
         # raise IndexError here).
         raw = _pad_to_header(raw, len(header))
+        row_consent, problem = _row_consent(raw, optional_col)
+        if problem:
+            skipped.append({"row": source_line, "reason": problem})
+            continue
         value, currency, problem = _parse_amount(
             raw[col["Conversion Value"]], raw[col["Conversion Currency"]]
         )
@@ -2136,6 +2394,10 @@ def _parse_ec_for_leads_csv(
             "conversion_value": value,
             "currency_code": currency,
             "order_id": order_id,
+            "consent": row_consent,
+            "consent_columns_present": any(
+                header in optional_col for header in _CONSENT_HEADERS
+            ),
         })
     return out, errors, advisories, skipped
 
@@ -2226,7 +2488,9 @@ def draft_upload_enhanced_conversions_for_leads(
     ``consent`` (GDPR/EEA): a dict like
     ``{"ad_user_data": "GRANTED", "ad_personalization": "DENIED"}``. Values:
     GRANTED / DENIED / UNSPECIFIED. Required for EEA traffic. Defaults to
-    UNSPECIFIED when omitted.
+    UNSPECIFIED when omitted. Optional ``Ad User Data`` /
+    ``Ad Personalization`` CSV columns say it per row and override this value
+    for the row that fills them in.
 
     Call confirm_and_apply with the returned plan_id to execute.
     """
@@ -2304,6 +2568,11 @@ def draft_upload_enhanced_conversions_for_leads(
         }
     rows = usable
 
+    consent_warnings = _consent_warnings(
+        rows,
+        columns_present=any(r.get("consent_columns_present") for r in rows),
+        default=consent_norm,
+    )
     distinct_actions = sorted({r["conversion_name"] for r in rows})
     total_value, totals_by_currency, currency_hint, value_warnings = (
         _value_summary(rows)
@@ -2369,6 +2638,11 @@ def draft_upload_enhanced_conversions_for_leads(
             f"Only {with_order_id} of {len(rows)} rows have an Order ID. "
             "Rows without one will double-count on re-upload."
         )
+    dedup_warnings.extend(
+        _duplicate_row_warnings(
+            rows, _ec_duplicate_key, "lead", order_id_of=_row_order_id
+        )
+    )
 
     # Freeze the hashed rows apply will upload. These are already SHA-256
     # hashes — NO raw PII. Safe to persist in the plan and (order_id/value/
@@ -2387,6 +2661,7 @@ def draft_upload_enhanced_conversions_for_leads(
             "conversion_value": r["conversion_value"],
             "currency_code": r["currency_code"],
             "order_id": r.get("order_id", ""),
+            "consent": _effective_consent(r.get("consent"), consent_norm),
         }
         for r in rows
     ]
@@ -2425,7 +2700,10 @@ def draft_upload_enhanced_conversions_for_leads(
             # Resolved at draft time; apply reads them instead of querying again.
             "conversion_actions": action_resources,
             "consent": consent_norm,
-            "parse_warnings": parse_advisories,
+            # What the rows actually upload with; ``consent`` alone is only the
+            # fallback and would misrepresent a file that sets it per row.
+            "consent_summary": _consent_summary(rows, consent_norm),
+            "parse_warnings": [*parse_advisories, *consent_warnings],
             "dedup_warnings": dedup_warnings,
             "match_warnings": _match_warnings(
                 names_without_address,
@@ -2447,6 +2725,7 @@ def draft_upload_enhanced_conversions_for_leads(
                     "conversion_value": r["conversion_value"],
                     "conversion_time": r["conversion_time"],
                     "order_id": r.get("order_id", ""),
+                    "consent": _effective_consent(r.get("consent"), consent_norm),
                 }
                 for r in rows[:3]
             ],
@@ -2484,7 +2763,7 @@ def _apply_upload_enhanced_conversions_for_leads(
                 cc.currency_code = r["currency_code"]
             if r.get("order_id"):
                 cc.order_id = r["order_id"]
-            _apply_consent(client, cc, consent)
+            _apply_consent(client, cc, r.get("consent") or consent)
 
             # Hashed identifiers only; Google matches them to logged-in users
             # who clicked the ads. A row with no usable identifier never gets

{adloop-0.24.0 → adloop-0.26.0}/src/adloop/ads/write.py

@@ -432,7 +432,7 @@ def _size_kb(data: bytes) -> float:
 
 def _describe_image(image: dict[str, object]) -> str:
     """One preview line: source, type, dimensions and size."""
-    source = image.get("url") or image.get("path")
+    source = image.get("url") or image.get("path") or f"upload {image.get('upload_id')}"
     kind = str(image.get("mime_type", "")).removeprefix("image/").upper()
     return (
         f"{source} — {kind} {image.get('width')}x{image.get('height')}, "
@@ -2457,12 +2457,14 @@ def draft_image_assets(
     campaign_id: str = "",
     image_paths: list[str] | None = None,
     image_urls: list[str] | None = None,
+    upload_ids: list[str] | None = None,
 ) -> dict:
-    """Draft campaign image assets from local files and/or public image URLs.
+    """Draft campaign image assets from local files, public image URLs and/or uploads.
 
     URL images are fetched now (public addresses only, pinned against DNS
     rebinding, capped at Google's 5120 KB limit) and their sha256 is kept
-    in the plan; apply re-fetches and refuses if the bytes changed.
+    in the plan; apply re-fetches and refuses if the bytes changed. Uploads
+    (``up_...`` ids from the upload card or link) are pinned the same way.
     """
     from adloop.runtime import deployment_mode
     from adloop.safety.guards import SafetyViolation, check_blocked_operation
@@ -2486,7 +2488,7 @@ def draft_image_assets(
         return {"error": str(e)}
 
     validated_images, errors = _validate_image_assets(
-        campaign_id, image_paths, image_urls
+        campaign_id, image_paths, image_urls, list(upload_ids or [])
     )
     if errors:
         return {"error": "Validation failed", "details": errors}
@@ -3300,16 +3302,38 @@ def _validate_structured_snippets(
 
 
 def _validate_image_assets(
-    campaign_id: str, image_paths: list[str], image_urls: list[str] | None = None
+    campaign_id: str,
+    image_paths: list[str],
+    image_urls: list[str] | None = None,
+    upload_ids: list[str] | None = None,
 ) -> tuple[list[dict[str, object]], list[str]]:
     errors = []
     validated = []
     image_urls = image_urls or []
+    upload_ids = upload_ids or []
 
     if not campaign_id:
         errors.append("campaign_id is required")
-    if not image_paths and not image_urls:
-        errors.append("At least one image (image_paths or image_urls) is required")
+    if not image_paths and not image_urls and not upload_ids:
+        errors.append("At least one image (image_paths, image_urls or upload_ids) is required")
+
+    for index, upload_id in enumerate(upload_ids):
+        from adloop.uploads import UploadError, current_tenant, get_upload_store
+
+        try:
+            upload, _data = get_upload_store().get(current_tenant(), upload_id)
+        except UploadError as exc:
+            errors.append(f"Upload {index + 1}: {exc}")
+            continue
+        validated.append({
+            "upload_id": upload.upload_id,
+            "sha256": upload.sha256,
+            "name": _build_image_asset_name(PurePosixPath(upload.name), _data),
+            "mime_type": upload.mime_type,
+            "width": upload.width,
+            "height": upload.height,
+            "size_kb": round(upload.size_bytes / 1024, 1),
+        })
 
     for index, image_path in enumerate(image_paths):
         try:
@@ -4916,6 +4940,13 @@ def _apply_create_image_assets(client: object, cid: str, changes: dict) -> dict:
         if payload.get("url"):
             image_bytes = _fetch_approved_image_url(payload)
             name_source = _url_path(str(payload["url"]))
+        elif payload.get("upload_id"):
+            from adloop.uploads import current_tenant, get_upload_store
+
+            upload, image_bytes = get_upload_store().get(current_tenant(), str(payload["upload_id"]))
+            if upload.sha256 != payload.get("sha256"):
+                raise ValueError(f"upload {upload.upload_id} changed since the preview; draft again.")
+            name_source = PurePosixPath(upload.name)
         elif deployment_mode() == "server":
             # Drafts refuse paths on a server; never read server files even
             # if a path-based plan reached apply some other way.