open-pharma-plugins 2.2.0__py3-none-any.whl

open_pharma_plugins_campaign_studio/tools/render_banner.py

@@ -0,0 +1,99 @@
+"""render_banner — merge validated copy into SVG banner template."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class RenderBannerArgs(BaseModel):
+    campaign_brief_id: str = Field(description="Links to the campaign")
+    dimensions: str = Field(
+        default="728x90",
+        description="WxH in pixels, e.g. '728x90', '300x250', '160x600'",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "render_banner",
+    "description": (
+        "Render an SVG banner from validated channel copy and brand components. "
+        "Refuses to run if validate_claims_and_fair_balance has not passed. "
+        "Merges headline, CTA, logo, and brand tokens into the SVG template. "
+        "Saves banner.svg to the campaign outputs directory."
+    ),
+    "args": RenderBannerArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+
+    from jinja2 import BaseLoader, Environment
+
+    from .._campaign_store import load_artifact, save_output
+    from .._renderer import (
+        check_validation_gate,
+        extract_copy_text,
+        load_brand_kit,
+        load_template,
+    )
+
+    campaign_brief_id = arguments["campaign_brief_id"]
+
+    gate_error = check_validation_gate(campaign_brief_id, "banner")
+    if gate_error:
+        return [{"type": "text", "text": json.dumps({"error": gate_error})}]
+
+    copy_artifact = load_artifact(campaign_brief_id, "copy-banner.json")
+    if not copy_artifact:
+        return [
+            {
+                "type": "text",
+                "text": json.dumps({"error": "No copy-banner.json found. Run generate_channel_copy for banner first."}),
+            }
+        ]
+
+    brand = load_brand_kit(campaign_brief_id)
+    copy_text = extract_copy_text(copy_artifact.get("copy", {}), "banner")
+
+    dims = arguments.get("dimensions", "728x90")
+    try:
+        width, height = (int(x) for x in dims.split("x"))
+    except (ValueError, AttributeError):
+        width, height = 728, 90
+
+    cta_text = copy_text.get("cta", "Learn More")
+    cta_width = max(80, len(cta_text) * 8 + 24)
+
+    headline_font_size = 16 if height >= 90 else 13
+
+    tpl_content = load_template("banner.svg.j2")
+    env = Environment(loader=BaseLoader(), autoescape=True)
+    tpl = env.from_string(tpl_content)
+
+    svg = tpl.render(
+        width=width,
+        height=height,
+        headline=copy_text.get("headline", ""),
+        sub_headline=copy_text.get("sub_headline"),
+        cta=cta_text,
+        cta_width=cta_width,
+        headline_font_size=headline_font_size,
+        logo_path=brand.get("logo_path", ""),
+        palette=brand.get("palette", {}),
+        typography=brand.get("typography", {}),
+    )
+
+    path = save_output(campaign_brief_id, "banner.svg", svg)
+
+    result = {
+        "campaign_brief_id": campaign_brief_id,
+        "channel": "banner",
+        "file_path": str(path),
+        "format": "svg",
+        "editable": True,
+        "dimensions": f"{width}x{height}",
+    }
+    return [{"type": "text", "text": json.dumps(result, indent=2)}]

open_pharma_plugins_campaign_studio/tools/render_email.py

@@ -0,0 +1,101 @@
+"""render_email — merge validated copy into email HTML template."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class RenderEmailArgs(BaseModel):
+    campaign_brief_id: str = Field(description="Links to the campaign")
+    template: str | None = Field(
+        default=None,
+        description="Custom template path; uses default email.html.j2 if omitted",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "render_email",
+    "description": (
+        "Render a self-contained HTML email from validated channel copy and "
+        "brand components. Refuses to run if validate_claims_and_fair_balance "
+        "has not passed. Merges copy blocks, brand colours, typography, logo, "
+        "and legal content into the email template. Saves email.html to the "
+        "campaign outputs directory."
+    ),
+    "args": RenderEmailArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+
+    from jinja2 import BaseLoader, Environment
+
+    from .._campaign_store import load_artifact, save_output
+    from .._renderer import (
+        check_validation_gate,
+        extract_copy_text,
+        load_brand_kit,
+        load_template,
+    )
+
+    campaign_brief_id = arguments["campaign_brief_id"]
+
+    gate_error = check_validation_gate(campaign_brief_id, "email")
+    if gate_error:
+        return [{"type": "text", "text": json.dumps({"error": gate_error})}]
+
+    copy_artifact = load_artifact(campaign_brief_id, "copy-email.json")
+    if not copy_artifact:
+        return [
+            {
+                "type": "text",
+                "text": json.dumps({"error": "No copy-email.json found. Run generate_channel_copy for email first."}),
+            }
+        ]
+
+    brief = load_artifact(campaign_brief_id, "campaign-brief.json") or {}
+    brand = load_brand_kit(campaign_brief_id)
+    copy_text = extract_copy_text(copy_artifact.get("copy", {}), "email")
+    legal = brand.get("legal", {})
+
+    template_str = arguments.get("template")
+    if template_str:
+        from pathlib import Path
+
+        tpl_content = Path(template_str).read_text()
+    else:
+        tpl_content = load_template("email.html.j2")
+
+    env = Environment(loader=BaseLoader(), autoescape=True)
+    tpl = env.from_string(tpl_content)
+
+    html = tpl.render(
+        brand=brief.get("brand", ""),
+        language=brief.get("language", "en"),
+        subject=copy_text.get("subject", ""),
+        headline=copy_text.get("headline", ""),
+        body_paragraphs=copy_text.get("body_paragraphs", []),
+        cta=copy_text.get("cta", ""),
+        safety_text=legal.get("isi", ""),
+        pi_ref=legal.get("pi_ref", ""),
+        copyright=legal.get("copyright", ""),
+        reporting=legal.get("reporting_statement", ""),
+        disclaimer=legal.get("disclaimer", ""),
+        logo_path=brand.get("logo_path", ""),
+        palette=brand.get("palette", {}),
+        typography=brand.get("typography", {}),
+    )
+
+    path = save_output(campaign_brief_id, "email.html", html)
+
+    result = {
+        "campaign_brief_id": campaign_brief_id,
+        "channel": "email",
+        "file_path": str(path),
+        "format": "html",
+        "editable": True,
+    }
+    return [{"type": "text", "text": json.dumps(result, indent=2)}]

open_pharma_plugins_campaign_studio/tools/render_poster.py

@@ -0,0 +1,222 @@
+"""render_poster — build a print-ready PDF poster using ReportLab."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class RenderPosterArgs(BaseModel):
+    campaign_brief_id: str = Field(description="Links to the campaign")
+    paper_size: str = Field(
+        default="A4",
+        description="A4 | letter | A3",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "render_poster",
+    "description": (
+        "Render a print-ready PDF poster from validated channel copy and brand "
+        "components using ReportLab. Refuses to run if "
+        "validate_claims_and_fair_balance has not passed. Includes headline, "
+        "body, CTA, safety block, and legal footer with brand styling. "
+        "Saves poster.pdf to the campaign outputs directory."
+    ),
+    "args": RenderPosterArgs,
+}
+
+_PAPER_SIZES = {
+    "A4": (595.28, 841.89),
+    "letter": (612, 792),
+    "A3": (841.89, 1190.55),
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+
+    from .._campaign_store import load_artifact, save_output_bytes
+    from .._renderer import (
+        check_validation_gate,
+        extract_copy_text,
+        load_brand_kit,
+    )
+
+    campaign_brief_id = arguments["campaign_brief_id"]
+
+    gate_error = check_validation_gate(campaign_brief_id, "poster")
+    if gate_error:
+        return [{"type": "text", "text": json.dumps({"error": gate_error})}]
+
+    copy_artifact = load_artifact(campaign_brief_id, "copy-poster.json")
+    if not copy_artifact:
+        return [
+            {
+                "type": "text",
+                "text": json.dumps({"error": "No copy-poster.json found. Run generate_channel_copy for poster first."}),
+            }
+        ]
+
+    brand = load_brand_kit(campaign_brief_id)
+    copy_text = extract_copy_text(copy_artifact.get("copy", {}), "poster")
+    legal = brand.get("legal", {})
+    palette = brand.get("palette", {})
+
+    paper = arguments.get("paper_size", "A4").upper()
+    page_w, page_h = _PAPER_SIZES.get(paper, _PAPER_SIZES["A4"])
+
+    pdf_bytes = _build_pdf(page_w, page_h, copy_text, palette, legal, brand)
+
+    path = save_output_bytes(campaign_brief_id, "poster.pdf", pdf_bytes)
+
+    result = {
+        "campaign_brief_id": campaign_brief_id,
+        "channel": "poster",
+        "file_path": str(path),
+        "format": "pdf",
+        "editable": False,
+        "paper_size": paper,
+    }
+    return [{"type": "text", "text": json.dumps(result, indent=2)}]
+
+
+def _build_pdf(
+    page_w: float,
+    page_h: float,
+    copy_text: dict,
+    palette: dict,
+    legal: dict,
+    brand: dict,
+) -> bytes:
+    import io
+    from xml.sax.saxutils import escape
+
+    from reportlab.lib.colors import HexColor
+    from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+    from reportlab.lib.units import mm
+    from reportlab.platypus import (
+        Paragraph,
+        SimpleDocTemplate,
+        Spacer,
+    )
+
+    buf = io.BytesIO()
+    margin = 20 * mm
+
+    doc = SimpleDocTemplate(
+        buf,
+        pagesize=(page_w, page_h),
+        leftMargin=margin,
+        rightMargin=margin,
+        topMargin=margin,
+        bottomMargin=margin,
+    )
+
+    primary = HexColor(palette.get("primary", "#003B5C"))
+    accent = HexColor(palette.get("accent", "#E8792F"))
+    text_color = HexColor(palette.get("text", "#1A202C"))
+    safety_color = HexColor(palette.get("safety_highlight", "#E53E3E"))
+
+    styles = getSampleStyleSheet()
+
+    headline_style = ParagraphStyle(
+        "Headline",
+        parent=styles["Title"],
+        fontSize=28,
+        textColor=primary,
+        spaceAfter=12,
+        leading=34,
+    )
+
+    subhead_style = ParagraphStyle(
+        "Subhead",
+        parent=styles["Heading2"],
+        fontSize=18,
+        textColor=primary,
+        spaceAfter=8,
+        leading=22,
+    )
+
+    body_style = ParagraphStyle(
+        "Body",
+        parent=styles["BodyText"],
+        fontSize=12,
+        textColor=text_color,
+        spaceAfter=8,
+        leading=16,
+    )
+
+    cta_style = ParagraphStyle(
+        "CTA",
+        parent=styles["BodyText"],
+        fontSize=14,
+        textColor=accent,
+        spaceBefore=12,
+        spaceAfter=12,
+        fontName="Helvetica-Bold",
+    )
+
+    safety_style = ParagraphStyle(
+        "Safety",
+        parent=styles["BodyText"],
+        fontSize=8,
+        textColor=safety_color,
+        spaceBefore=16,
+        spaceAfter=4,
+        leading=10,
+    )
+
+    legal_style = ParagraphStyle(
+        "Legal",
+        parent=styles["BodyText"],
+        fontSize=7,
+        textColor=HexColor("#718096"),
+        spaceBefore=8,
+        leading=9,
+    )
+
+    story: list = []
+
+    headline = copy_text.get("headline", "")
+    if headline:
+        story.append(Paragraph(escape(headline), headline_style))
+
+    subhead = copy_text.get("subhead", "")
+    if subhead:
+        story.append(Paragraph(escape(subhead), subhead_style))
+
+    story.append(Spacer(1, 8))
+
+    for para in copy_text.get("body_paragraphs", []):
+        if para:
+            story.append(Paragraph(escape(para), body_style))
+
+    for bullet in copy_text.get("bullet_points", []):
+        if bullet:
+            story.append(Paragraph(f"• {escape(bullet)}", body_style))
+
+    cta = copy_text.get("cta", "")
+    if cta:
+        story.append(Paragraph(escape(cta), cta_style))
+
+    isi = legal.get("isi", "")
+    if isi:
+        story.append(Paragraph("<b>IMPORTANT SAFETY INFORMATION</b>", safety_style))
+        story.append(Paragraph(escape(isi), safety_style))
+
+    legal_parts = []
+    for key in ("pi_ref", "copyright", "reporting_statement", "disclaimer"):
+        val = legal.get(key, "")
+        if val:
+            legal_parts.append(escape(val))
+    if legal_parts:
+        story.append(Paragraph("<br/>".join(legal_parts), legal_style))
+
+    for fn in copy_text.get("footnotes", []):
+        if fn:
+            story.append(Paragraph(escape(fn), legal_style))
+
+    doc.build(story)
+    return buf.getvalue()

open_pharma_plugins_campaign_studio/tools/retrieve_approved_claims.py

@@ -0,0 +1,71 @@
+"""retrieve_approved_claims — load and filter approved claims for a campaign."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class RetrieveApprovedClaimsArgs(BaseModel):
+    campaign_brief_id: str = Field(description="Links claims to the campaign")
+    source: str | None = Field(
+        default=None,
+        description="Path to claims JSON; uses brief's path or fixture if omitted",
+    )
+    categories: list[str] | None = Field(
+        default=None,
+        description="Filter: efficacy | safety | tolerability | dosing | positioning | MOA",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "retrieve_approved_claims",
+    "description": (
+        "Load the approved claims set for a campaign. Reads from a JSON file "
+        "containing ApprovedClaim objects. Optionally filter by category. "
+        "Persists the claims to the campaign directory for downstream tools. "
+        "If no source is specified, uses the path from the campaign brief or "
+        "the built-in sample ONCORIX fixture."
+    ),
+    "args": RetrieveApprovedClaimsArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+    from importlib.resources import files
+    from pathlib import Path
+
+    from .._campaign_store import load_brief, save_artifact
+
+    campaign_brief_id = arguments["campaign_brief_id"]
+    source = arguments.get("source")
+    categories = arguments.get("categories")
+
+    if not source:
+        brief = load_brief(campaign_brief_id)
+        if brief and brief.get("approved_claims_path"):
+            source = brief["approved_claims_path"]
+
+    claims: list[dict] = []
+
+    if source and Path(source).is_file():
+        claims = json.loads(Path(source).read_text())
+    else:
+        fixture_path = files("open_pharma_plugins_campaign_studio") / "fixtures" / "sample_approved_claims.json"
+        claims = json.loads(fixture_path.read_text())
+
+    if categories:
+        cat_set = {c.lower() for c in categories}
+        claims = [c for c in claims if c.get("category", "").lower() in cat_set]
+
+    save_artifact(campaign_brief_id, "approved-claims.json", claims)
+
+    result = {
+        "campaign_brief_id": campaign_brief_id,
+        "total_claims": len(claims),
+        "categories": sorted({c.get("category", "") for c in claims}),
+        "claims": claims,
+    }
+    return [{"type": "text", "text": json.dumps(result, indent=2)}]

open_pharma_plugins_campaign_studio/tools/retrieve_brand_components.py

@@ -0,0 +1,76 @@
+"""retrieve_brand_components — load brand kit assets for rendering."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class RetrieveBrandComponentsArgs(BaseModel):
+    campaign_brief_id: str = Field(description="Links to the campaign")
+    brand_kit_path: str | None = Field(
+        default=None,
+        description="Override path to brand kit directory; uses brief's path or fixture if omitted",
+    )
+
+
+TOOL: dict[str, Any] = {
+    "name": "retrieve_brand_components",
+    "description": (
+        "Load brand components (logo, product image, colour palette, typography, "
+        "and legal content) for a campaign. Returns paths and structured data "
+        "for use by renderers. If no path is specified, uses the path from the "
+        "campaign brief or the built-in sample brand kit."
+    ),
+    "args": RetrieveBrandComponentsArgs,
+}
+
+
+def handle(arguments: dict[str, Any]) -> list[dict[str, Any]]:
+    import json
+    from importlib.resources import files
+    from pathlib import Path
+
+    from .._campaign_store import load_brief
+
+    campaign_brief_id = arguments["campaign_brief_id"]
+    kit_path = arguments.get("brand_kit_path")
+
+    if not kit_path:
+        brief = load_brief(campaign_brief_id)
+        if brief and brief.get("brand_kit_path"):
+            kit_path = brief["brand_kit_path"]
+
+    if kit_path and Path(kit_path).is_dir():
+        kit_dir = Path(kit_path)
+    else:
+        kit_dir = Path(str(files("open_pharma_plugins_campaign_studio") / "fixtures" / "brand_kit"))
+
+    palette = _load_json(kit_dir / "palette.json")
+    typography = _load_json(kit_dir / "typography.json")
+    legal = _load_json(kit_dir / "legal.json")
+
+    logo_path = kit_dir / "logo.svg"
+    product_path = kit_dir / "product.png"
+
+    result = {
+        "campaign_brief_id": campaign_brief_id,
+        "brand_kit_path": str(kit_dir),
+        "logo_path": str(logo_path) if logo_path.exists() else None,
+        "product_image_path": str(product_path) if product_path.exists() else None,
+        "palette": palette,
+        "typography": typography,
+        "legal": legal,
+    }
+    return [{"type": "text", "text": json.dumps(result, indent=2)}]
+
+
+def _load_json(path) -> dict:
+    import json
+    from pathlib import Path
+
+    p = Path(path)
+    if p.exists():
+        return json.loads(p.read_text())
+    return {}