syntaxmatrix 2.5.5.5__py3-none-any.whl → 2.6.2__py3-none-any.whl

syntaxmatrix/media/media_pixabay.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+import hashlib
+import io
+import os
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import requests
+from PIL import Image
+
+
+PIXABAY_API_URL = "https://pixabay.com/api/"
+
+
+@dataclass
+class PixabayHit:
+    id: int
+    page_url: str
+    tags: str
+    user: str
+    preview_url: str
+    webformat_url: str
+    large_image_url: str
+    width: int
+    height: int
+    image_type: str
+
+
+def _clean_query(q: str) -> str:
+    q = (q or "").strip()
+    q = re.sub(r"\s+", " ", q)
+    return q[:100]
+
+
+def pixabay_search(
+    api_key: str,
+    query: str,
+    *,
+    image_type: str = "photo",
+    orientation: str = "horizontal",
+    per_page: int = 24,
+    page: int = 1,
+    safesearch: bool = True,
+    editors_choice: bool = False,
+    min_width: int = 0,
+    min_height: int = 0,
+    timeout: int = 15,
+) -> List[PixabayHit]:
+    """Search Pixabay and return normalised hits."""
+    if not api_key:
+        return []
+
+    q = _clean_query(query)
+    if not q:
+        return []
+
+    per_page = max(3, min(200, int(per_page or 24)))
+    page = max(1, int(page or 1))
+
+    params = {
+        "key": api_key,
+        "q": q,
+        "image_type": image_type or "photo",
+        "orientation": orientation or "all",
+        "per_page": per_page,
+        "page": page,
+        "safesearch": "true" if safesearch else "false",
+        "editors_choice": "true" if editors_choice else "false",
+        "min_width": int(min_width or 0),
+        "min_height": int(min_height or 0),
+        "order": "popular",
+    }
+
+    r = requests.get(PIXABAY_API_URL, params=params, timeout=timeout)
+    r.raise_for_status()
+    data = r.json() or {}
+    hits = data.get("hits") or []
+
+    out: List[PixabayHit] = []
+    for h in hits:
+        try:
+            out.append(
+                PixabayHit(
+                    id=int(h.get("id")),
+                    page_url=str(h.get("pageURL") or ""),
+                    tags=str(h.get("tags") or ""),
+                    user=str(h.get("user") or ""),
+                    preview_url=str(h.get("previewURL") or ""),
+                    webformat_url=str(h.get("webformatURL") or ""),
+                    large_image_url=str(h.get("largeImageURL") or ""),
+                    width=int(h.get("imageWidth") or 0),
+                    height=int(h.get("imageHeight") or 0),
+                    image_type=str(h.get("type") or image_type or "photo"),
+                )
+            )
+        except Exception:
+            continue
+
+    return out
+
+
+def _is_pixabay_url(url: str) -> bool:
+    url = (url or "").strip().lower()
+    return url.startswith("https://") and ("pixabay.com" in url)
+
+
+def _sha256_bytes(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()
+
+
+def _dhash_hex(img: Image.Image, size: int = 8) -> str:
+    g = img.convert("L").resize((size + 1, size), Image.LANCZOS)
+    px = list(g.getdata())
+    rows = [px[i * (size + 1):(i + 1) * (size + 1)] for i in range(size)]
+    bits = []
+    for row in rows:
+        for x in range(size):
+            bits.append(1 if row[x] > row[x + 1] else 0)
+
+    val = 0
+    for b in bits:
+        val = (val << 1) | b
+    return f"{val:0{size*size//4}x}"
+
+
+def download_and_store_image(
+    url: str,
+    *,
+    out_path_no_ext: str,
+    max_width: int = 1920,
+    thumb_dir: Optional[str] = None,
+    thumb_width: int = 800,
+    timeout: int = 20,
+    min_width: int = 0,
+    fallback_url: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Downloads an image from Pixabay.
+
+    Rule:
+      - Always try `url` first (webformat).
+      - If `min_width` is set and the downloaded image is narrower than min_width,
+        then try `fallback_url` (large) once, and keep it only if it's larger.
+      - Then resize down to max_width (1920).
+      - Save as JPG unless image has alpha channel (then PNG).
+      - Create thumbnail only if width > 800px (your rule).
+    """
+
+    def _fetch(u: str) -> bytes:
+        if not _is_pixabay_url(u):
+            raise ValueError("Only Pixabay URLs are allowed")
+        rr = requests.get(u, stream=True, timeout=timeout)
+        rr.raise_for_status()
+        return rr.content
+
+    # 1) Fetch webformat first
+    content = _fetch(url)
+    img = Image.open(io.BytesIO(content))
+    img.load()
+
+    # 2) If too small (e.g., hero) try large variant once
+    if min_width and img.width < int(min_width) and fallback_url:
+        try:
+            content2 = _fetch(fallback_url)
+            img2 = Image.open(io.BytesIO(content2))
+            img2.load()
+            if img2.width > img.width:
+                content = content2
+                img = img2
+        except Exception:
+            # If large fetch fails, keep webformat result
+            pass
+
+    # 3) Resize down to max_width (never upsample)
+    if img.width > int(max_width or 1920):
+        ratio = (int(max_width) / float(img.width))
+        new_h = max(1, int(round(img.height * ratio)))
+        img = img.resize((int(max_width), new_h), Image.LANCZOS)
+
+    # 4) Decide output format
+    has_alpha = ("A" in img.getbands())
+    ext = ".png" if has_alpha else ".jpg"
+    out_path = out_path_no_ext + ext
+    os.makedirs(os.path.dirname(out_path), exist_ok=True)
+
+    # 5) Encode + save
+    buf = io.BytesIO()
+    if ext == ".jpg":
+        rgb = img.convert("RGB") if img.mode != "RGB" else img
+        rgb.save(buf, "JPEG", quality=85, optimize=True, progressive=True)
+        mime = "image/jpeg"
+    else:
+        img.save(buf, "PNG", optimize=True)
+        mime = "image/png"
+
+    data = buf.getvalue()
+    with open(out_path, "wb") as f:
+        f.write(data)
+
+    meta = {
+        "file_path": out_path,
+        "width": img.width,
+        "height": img.height,
+        "sha256": _sha256_bytes(data),
+        "dhash": _dhash_hex(img),
+        "mime": mime,
+    }
+
+    # 6) Thumbnail only if width > 800px (your rule)
+    if thumb_dir and img.width > int(thumb_width or 800):
+        os.makedirs(thumb_dir, exist_ok=True)
+        thumb = img.copy()
+        ratio = (int(thumb_width) / float(thumb.width))
+        new_h = max(1, int(round(thumb.height * ratio)))
+        thumb = thumb.resize((int(thumb_width), new_h), Image.LANCZOS)
+
+        thumb_path = os.path.join(
+            thumb_dir,
+            os.path.basename(out_path_no_ext) + f"-t{int(thumb_width)}.jpg"
+        )
+
+        tb = io.BytesIO()
+        thumb_rgb = thumb.convert("RGB") if thumb.mode != "RGB" else thumb
+        thumb_rgb.save(tb, "JPEG", quality=82, optimize=True, progressive=True)
+        with open(thumb_path, "wb") as f:
+            f.write(tb.getvalue())
+
+        meta["thumb_path"] = thumb_path
+
+    return meta
+
+def import_pixabay_hit(
+    hit: PixabayHit,
+    *,
+    media_images_dir: str,
+    thumbs_dir: Optional[str] = None,
+    max_width: int = 1920,
+    thumb_width: int = 800,
+    min_width: int = 0,
+) -> Dict[str, Any]:
+    # Efficient by default: use webformat first.
+    url = hit.webformat_url or hit.large_image_url
+    if not url:
+        raise ValueError("No image url")
+
+    if not _is_pixabay_url(url):
+        raise ValueError("Only Pixabay URLs are allowed")
+
+    # Only use large as fallback when webformat is too small for the use-case (e.g., hero)
+    fallback = None
+    if url == hit.webformat_url and hit.large_image_url and hit.large_image_url != hit.webformat_url:
+        fallback = hit.large_image_url
+
+    out_base = os.path.join(media_images_dir, f"pixabay-{hit.id}")
+
+    meta = download_and_store_image(
+        url,
+        out_path_no_ext=out_base,
+        max_width=max_width,
+        thumb_dir=thumbs_dir,
+        thumb_width=thumb_width,
+        min_width=min_width,
+        fallback_url=fallback,
+    )
+
+    meta.update(
+        {
+            "source": "pixabay",
+            "source_url": hit.page_url,
+            "author": hit.user,
+            "tags": hit.tags,
+            "pixabay_id": hit.id,
+        }
+    )
+    return meta

syntaxmatrix/models.py

@@ -8,7 +8,7 @@ class Workspace(db.Model):
     name          = db.Column(db.String(64), unique=True, nullable=False)
     llm_provider  = db.Column(db.String(24), default="openai")
     llm_model     = db.Column(db.String(48), default="gpt-3.5-turbo")
-    llm_api_key   = db.Column(db.LargeBinary)      # we'll encrypt later
+    llm_api_key   = db.Column(db.LargeBinary)     
 
     def __repr__(self):
         return f"<Workspace {self.name}>"

syntaxmatrix/page_builder_defaults.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import html as _html
+import re as _re
+from typing import Any, Dict, List
+
+
+def _title_from_slug(slug: str) -> str:
+    s = (slug or "").strip().replace("_", " ").replace("-", " ")
+    s = _re.sub(r"\s+", " ", s).strip()
+    if not s:
+        return "New page"
+    return s[:1].upper() + s[1:]
+
+
+def make_default_layout(page_name: str, website_description: str = "") -> Dict[str, Any]:
+    """Create a starter layout JSON for the drag-and-drop page builder."""
+    page = (page_name or "page").strip().lower()
+    desc = (website_description or "").strip()
+
+    def sec(_id: str, _type: str, title: str, text: str, cols: int, items: List[Dict[str, Any]]):
+        return {
+            "id": _id,
+            "type": _type,
+            "title": title,
+            "text": text,
+            "cols": cols,
+            "items": items or [],
+        }
+
+    def item(_id: str, _type: str, title: str, text: str, image_url: str = ""):
+        return {
+            "id": _id,
+            "type": _type,
+            "title": title,
+            "text": text,
+            "imageUrl": image_url or "",
+        }
+
+    hero_title = _title_from_slug(page)
+    hero_text = desc or "Describe your offering here. Replace this text with your own message."
+
+    return {
+        "page": page,
+        "sections": [
+            sec(
+                "sec_hero",
+                "hero",
+                hero_title,
+                hero_text,
+                1,
+                [
+                    item("item_hero_1", "card", "Get started", "Add a short call-to-action here.", ""),
+                ],
+            ),
+            sec(
+                "sec_features",
+                "features",
+                "Features",
+                "Three quick reasons people choose you.",
+                3,
+                [
+                    item("item_feat_1", "card", "Fast setup", "Be up and running quickly.", ""),
+                    item("item_feat_2", "card", "Secure by design", "Built with sensible defaults.", ""),
+                    item("item_feat_3", "card", "Support that cares", "We help you succeed.", ""),
+                ],
+            ),
+            sec(
+                "sec_gallery",
+                "gallery",
+                "Gallery",
+                "Add images that show your product, team, or work.",
+                3,
+                [
+                    item("item_gal_1", "card", "Image", "Drop an image onto this card.", ""),
+                    item("item_gal_2", "card", "Image", "Drop an image onto this card.", ""),
+                    item("item_gal_3", "card", "Image", "Drop an image onto this card.", ""),
+                ],
+            ),
+            sec(
+                "sec_testimonials",
+                "testimonials",
+                "Testimonials",
+                "A couple of short quotes from customers.",
+                2,
+                [
+                    item("item_test_1", "quote", "Customer name", "“A short customer quote goes here.”", ""),
+                    item("item_test_2", "quote", "Customer name", "“Another short quote goes here.”", ""),
+                ],
+            ),
+            sec(
+                "sec_faq",
+                "faq",
+                "FAQ",
+                "Answer the most common questions upfront.",
+                2,
+                [
+                    item("item_faq_1", "faq", "What do you offer?", "Explain in one or two sentences.", ""),
+                    item("item_faq_2", "faq", "How do I get started?", "Tell them the first step.", ""),
+                ],
+            ),
+            sec(
+                "sec_cta",
+                "cta",
+                "Ready to talk?",
+                "Add a clear call-to-action with next steps.",
+                2,
+                [
+                    item("item_cta_1", "card", "Book a demo", "Invite people to contact you.", ""),
+                    item("item_cta_2", "card", "Email us", "Add your preferred contact method.", ""),
+                ],
+            ),
+        ],
+    }
+
+
+def _esc(s: str) -> str:
+    return _html.escape(s or "", quote=True)
+
+
+def layout_to_html(st: Dict[str, Any]) -> str:
+    """Render layout JSON into HTML snippets used by /page/<page_name>."""
+    sections = st.get("sections") if isinstance(st, dict) else None
+    if not isinstance(sections, list):
+        return ""
+
+    blocks: List[str] = []
+
+    for s in sections:
+        if not isinstance(s, dict):
+            continue
+
+        title = _esc(s.get("title") or "")
+        text = _esc(s.get("text") or "")
+
+        try:
+            cols = int(s.get("cols") or 1)
+        except Exception:
+            cols = 1
+        cols = max(1, min(5, cols))
+
+        items_html: List[str] = []
+        for it in (s.get("items") or []):
+            if not isinstance(it, dict):
+                continue
+
+            it_title = _esc(it.get("title") or "")
+            it_text = _esc(it.get("text") or "")
+            img = (it.get("imageUrl") or "").strip()
+
+            img_html = (
+                f'<img src="{_esc(img)}" alt="{it_title}" style="width:100%;height:auto;border-radius:12px;">'
+                if img else ""
+            )
+
+            items_html.append(
+                '<div style="border:1px solid rgba(148,163,184,.25);border-radius:16px;'
+                'padding:14px;background:rgba(15,23,42,.35);">'
+                f'{img_html}'
+                f'<h3 style="margin:10px 0 6px;font-size:1.05rem;">{it_title}</h3>'
+                f'<p style="margin:0;color:#cbd5e1;line-height:1.5;">{it_text}</p>'
+                '</div>'
+            )
+
+        grid = ""
+        if items_html:
+            joined = "\n".join(items_html)
+            grid = (
+                f'<div style="display:grid;gap:12px;grid-template-columns:repeat({cols}, minmax(0,1fr));">'
+                f'{joined}</div>'
+            )
+
+        p = f'<p style="margin:0 0 14px;color:#cbd5e1;line-height:1.55;">{text}</p>' if text else ""
+
+        blocks.append(
+            '<section style="max-width:1100px;margin:22px auto;padding:0 14px;">'
+            f'<h2 style="margin:0 0 8px;font-size:1.6rem;">{title}</h2>'
+            f'{p}'
+            f'{grid}'
+            '</section>'
+        )
+
+    return "\n\n".join(blocks)