Adapt class to schema

2025-11-15 19:16 UTC gpt-5-1-thinking Open in ChatGPT ↗

You

I want this class to be adapted to the following schema. Even better, can the class be auto-generated somehow just be using the schema?

class:

@dataclass class ProjectV15: """ ProjectV15 model based on the provided YAML schema.

Fields:
  - title: string (required)
  - short_title: string (required)
  - slug: string (required, kebab-case)
  - thumbnail: image (required)
  - client: reference to collaborators (optional, single)
  - collabs: list of collaborators (optional)
  - date: date (optional) - expected as a string in dd-MM-yyyy format or a datetime
  - summary: string (optional)
  - body: rich-text content (optional)
  - tag: string (optional)
  - gallery: list of image paths (optional)
  - videos: list of video URLs (optional)
  - external_url: string (optional)
  - order: number (default 100)
  - featured: boolean (default False)
  - seo: dictionary or SEO component (optional)
"""

def __init__(
    self,
    title: str,
    short_title: str,
    slug: str,
    thumbnail: str,
    client: Optional[str] = None,
    collabs: Optional[List[str]] = None,
    date: Optional[str] = None,
    summary: Optional[str] = None,
    body: Optional[str] = None,
    tag: Optional[str] = None,
    gallery: Optional[List[str]] = None,
    videos: Optional[List[Video]] = None,
    external_url: Optional[str] = None,
    order: int = 100,
    featured: bool = False,
    seo: Optional[Dict[str, Any]] = None,
):
    # Required fields
    self.title = title
    self.short_title = short_title
    self.slug = slug
    self.thumbnail = thumbnail

    # Optional/relations
    self.client = client
    self.collabs = collabs or []
    self.date = self._parse_date(date) if date is not None else None
    self.summary = summary
    self.body = body
    self.tag = tag
    self.gallery = gallery or []
    self.videos = videos or []
    self.external_url = external_url

    # Misc
    self.order = int(order)
    self.featured = bool(featured)
    self.seo = seo or {}

@staticmethod
def _parse_date(date_input: Any) -> Optional[datetime]:
    """
    Accepts a date as:
    - string in formats like "dd-MM-yyyy" or "YYYY-MM-DD"
    - datetime.date or datetime.datetime
    Returns datetime.date if possible, else None.
    """
    if isinstance(date_input, datetime):
        return date_input
    if hasattr(date_input, "strftime"):
        return date_input  # already date-like
    if isinstance(date_input, str):
        for fmt in ("%d-%m-%Y", "%d-%m-%Y %H:%M:%S", "%Y-%m-%d"):
            try:
                return datetime.strptime(date_input, fmt)
            except ValueError:
                continue
    return None

@classmethod
def from_pages_cms(cls, data: Dict[str, Any]) -> "ProjectV15":
    """
    Convenience constructor to build a Project_v15 from a dict
    that matches the YAML schema.
    """
    return cls(
        title=data.get("title"),
        short_title=data.get("short_title"),
        slug=data.get("slug"),
        thumbnail=data.get("thumbnail"),
        client=data.get("client"),
        collabs=data.get("collabs"),
        date=data.get("date"),
        summary=data.get("summary"),
        body=data.get("body").split("\n\n"),
        tag=data.get("tag"),
        gallery=data.get("gallery"),
        videos=data.get("videos"),
        external_url=data.get("external_url"),
        order=data.get("order", 100),
        featured=data.get("featured", False),
        seo=data.get("seo"),
    )

def to_dict(self) -> Dict[str, Any]:
    """
    Serializes the Project_v15 instance back to a dictionary.
    Useful for debugging or emitting YAML/JSON.
    """
    return {
        "title": self.title,
        "short_title": self.short_title,
        "slug": self.slug,
        "thumbnail": self.thumbnail,
        "client": self.client,
        "collabs": self.collabs,
        "date": self.date.isoformat() if isinstance(self.date, datetime) else self.date,
        "summary": self.summary,
        "body": self.body,
        "tag": self.tag,
        "gallery": self.gallery,
        "videos": self.videos,
        "external_url": self.external_url,
        "order": self.order,
        "featured": self.featured,
        "seo": self.seo,
    }

def to_html( self, env: Environment, web_info: WebsiteInfo, template_path: str = 'ulc_project_template_v15.html.j2' ):
    template = env.get_template(template_path)

    # Render the template with the data from the Notion page
    html = template.render(company_full_name=web_info.company_full_name,
                           company_description=web_info.company_description,
                           navigation=web_info.navigation,
                           main_logo=web_info.main_logo,

                           project_title=self.title,
                           project_date=self.date,
                           project_summary=self.summary,
                           videos=self.videos,
                           images=self.gallery,
                           paragraphs=self.body,
                           collaborators=self.collabs
                           )
    return html

def __str__ ( self ) -> str:
    return json.dumps(self.to_dict(), indent=2, ensure_ascii=False)

schema:

fields: - name: title label: Project title type: string required: true - name: short_title label: Short title type: string required: true - name: slug label: Slug (used for filename/URL) type: string pattern: regex: ”^[a-z0-9]+(?:-[a-z0-9]+)*$” message: “use-kebab-case” required: true - name: thumbnail label: Grid thumbnail type: image required: true - name: client label: Client / Project Leader type: object fields: - name: client_info label: Select from Clients type: select options: placeholder: Select… fetch: url: https://www.uncharted-limbo.com/api/notion/clients method: GET results: items cache: false - name: client_role label: Role in Project type: select description: > Select who originated or owns the project: • Client – commercial or brand-led
• Commissioned By – institutional or cultural
• Produced By – co-production
• Presented By – exhibition/festival
• Supported By – grant/sponsor
• In Collaboration With – partnership
• Initiated By – concept originated externally

        options:
          values: [
            Client,
            Commissioned By,
            Produced By,
            Presented By,
            Supported By,
            In Collaboration With,
            Initiated By
          ]
  - name: collabs
    label: Collaborators
    type: object
    list: true
    fields:
      - name: collaborator_info
        label: Select from Collaborators
        type: select
        options:
            placeholder: Select…
            fetch:
              url: https://www.uncharted-limbo.com/api/notion/collaborators
              method: GET
              results: items
              cache: false
      - name: role
        label: Role in Project
        type: text
    options:
      multiple: true
  - name: date
    label: Date
    type: date
    options:
      format: dd-MM-yyyy
      min: 2020-09-01
  - name: summary
    label: Short summary
    type: text
  - name: body
    label: Case study body
    type: rich-text
  - name: tag
    label: Tags
    type: string
  - name: gallery
    label: Gallery images
    type: image
    options:
      multiple:
        max: 16
  - name: videos
    label: Videos
    type: string
    list: true
    placeholder: "https://youtu.be/XXXXXXXXXXX"
  - name: awards
    label: Awards
    type: reference
    list: true
    options:
      collection: awards
      multiple: true
  - name: external_url
    label: External link (optional)
    type: string
  - name: order
    label: Grid order (lower = earlier)
    type: number
    default: 100
  - name: featured
    label: Pin to featured
    type: boolean
    default: false
  - name: seo
    label: SEO
    component: seo

ChatGPT

[Unsupported Content]

ChatGPT

[Unsupported Content]

ChatGPT

You can definitely adapt this class to match the schema more closely, and yes – you can auto-generate a class from the schema (at least for most of it) instead of hand-coding everything.

I’ll do two things:

1. Show a cleaned-up @dataclass version of ProjectV15 that matches your schema (including client, collabs, awards, and the new videos type).
2. Show how to auto-generate a dataclass from the schema using make_dataclass.

---

1. Dataclass adapted to your schema

Key changes vs your original:

• client is now an object with client_info and client_role.
• collabs is a list of objects: collaborator_info + role.
• videos is now List[str] (schema says type: string, list: true).
• awards added as List[str] (or List[Dict[str, Any]] if your CMS returns objects).
• Using a real @dataclass with __post_init__ instead of a custom __init__.
• Date parsing moved to __post_init__.
• to_html now uses collaborator_info when passing collaborators to the template.

from __future__ import annotations

import json
from dataclasses import dataclass, field
from datetime import datetime
from typing import Any, Dict, List, Optional

from jinja2 import Environment

# ---- Helper dataclasses for nested schema fields ----

@dataclass
class ClientRef:
    client_info: Optional[str] = None
    client_role: Optional[str] = None

@dataclass
class CollaboratorRef:
    collaborator_info: Optional[str] = None
    role: Optional[str] = None

@dataclass
class ProjectV15:
    """
    ProjectV15 model aligned with the YAML schema.

    Fields:
      - title: string (required)
      - short_title: string (required)
      - slug: string (required, kebab-case)
      - thumbnail: image (required)
      - client: object { client_info, client_role } (optional)
      - collabs: list of { collaborator_info, role } (optional)
      - date: date (optional) - parsed into datetime
      - summary: string (optional)
      - body: rich-text content (optional) – represented here as list[str] paragraphs
      - tag: string (optional)
      - gallery: list of image paths (optional)
      - videos: list of video URLs (optional)
      - awards: list of award references (optional)
      - external_url: string (optional)
      - order: number (default 100)
      - featured: boolean (default False)
      - seo: dictionary or SEO component (optional)
    """

    # Required
    title: str
    short_title: str
    slug: str
    thumbnail: str

    # Optional / nested
    client: Optional[ClientRef] = None
    collabs: List[CollaboratorRef] = field(default_factory=list)

    date: Optional[datetime] = None
    summary: Optional[str] = None
    # Represent rich-text as list of paragraphs (adapt if your CMS returns blocks)
    body: Optional[List[str]] = None

    tag: Optional[str] = None
    gallery: List[str] = field(default_factory=list)
    videos: List[str] = field(default_factory=list)
    awards: List[str] = field(default_factory=list)
    external_url: Optional[str] = None

    order: int = 100
    featured: bool = False
    seo: Dict[str, Any] = field(default_factory=dict)

    # --- post-init normalization ---

    def __post_init__(self):
        # Ensure order / featured types
        self.order = int(self.order)
        self.featured = bool(self.featured)

        # Normalize date
        if self.date is not None:
            self.date = self._parse_date(self.date)

        # Normalize sequences (defensive against None)
        self.collabs = list(self.collabs or [])
        self.gallery = list(self.gallery or [])
        self.videos = list(self.videos or [])
        self.awards = list(self.awards or [])

        # Normalize body: allow string, list[str], or None
        if isinstance(self.body, str):
            # Keep your existing behavior: split on blank lines
            self.body = [p for p in self.body.split("\n\n") if p.strip()]
        elif self.body is None:
            self.body = []

        # Normalize seo
        self.seo = dict(self.seo or {})

    # --- helpers ---

    @staticmethod
    def _parse_date(date_input: Any) -> Optional[datetime]:
        """
        Accepts a date as:
        - string in formats like "dd-MM-yyyy" or "YYYY-MM-DD"
        - datetime.date or datetime.datetime
        Returns datetime if possible, else None.
        """
        if isinstance(date_input, datetime):
            return date_input
        if hasattr(date_input, "strftime"):  # datetime.date or similar
            # Convert to datetime at midnight
            return datetime(
                year=date_input.year,
                month=date_input.month,
                day=date_input.day,
            )
        if isinstance(date_input, str):
            for fmt in ("%d-%m-%Y", "%d-%m-%Y %H:%M:%S", "%Y-%m-%d"):
                try:
                    return datetime.strptime(date_input, fmt)
                except ValueError:
                    continue
        return None

    # --- factory from CMS dict ---

    @classmethod
    def from_pages_cms(cls, data: Dict[str, Any]) -> "ProjectV15":
        """
        Build a ProjectV15 from the CMS dict that directly follows the YAML schema.
        """

        # client: { client_info, client_role }
        raw_client = data.get("client")
        client_obj: Optional[ClientRef] = None
        if isinstance(raw_client, dict):
            client_obj = ClientRef(
                client_info=raw_client.get("client_info"),
                client_role=raw_client.get("client_role"),
            )

        # collabs: list of { collaborator_info, role }
        raw_collabs = data.get("collabs") or []
        collab_objs: List[CollaboratorRef] = []
        for c in raw_collabs:
            if isinstance(c, dict):
                collab_objs.append(
                    CollaboratorRef(
                        collaborator_info=c.get("collaborator_info"),
                        role=c.get("role"),
                    )
                )

        # videos: list of strings (URLs)
        videos = data.get("videos") or []

        # awards: reference list – assume list of strings/ids
        awards = data.get("awards") or []

        # body: rich-text
        raw_body = data.get("body")
        # If CMS sends a long string, keep your old behavior (split by blank line)
        if isinstance(raw_body, str):
            body = [p for p in raw_body.split("\n\n") if p.strip()]
        else:
            # Could be list[blocks] or already list[str]; just pass through
            body = raw_body

        return cls(
            title=data["title"],
            short_title=data["short_title"],
            slug=data["slug"],
            thumbnail=data["thumbnail"],
            client=client_obj,
            collabs=collab_objs,
            date=data.get("date"),
            summary=data.get("summary"),
            body=body,
            tag=data.get("tag"),
            gallery=data.get("gallery") or [],
            videos=videos,
            awards=awards,
            external_url=data.get("external_url"),
            order=data.get("order", 100),
            featured=data.get("featured", False),
            seo=data.get("seo") or {},
        )

    # --- serialization ---

    def to_dict(self) -> Dict[str, Any]:
        """
        Serialize back to a dict matching the CMS/YAML structure as closely as possible.
        """
        client_dict = (
            {
                "client_info": self.client.client_info,
                "client_role": self.client.client_role,
            }
            if self.client is not None
            else None
        )

        collabs_list = [
            {
                "collaborator_info": c.collaborator_info,
                "role": c.role,
            }
            for c in self.collabs
        ]

        return {
            "title": self.title,
            "short_title": self.short_title,
            "slug": self.slug,
            "thumbnail": self.thumbnail,
            "client": client_dict,
            "collabs": collabs_list,
            "date": self.date.isoformat() if isinstance(self.date, datetime) else self.date,
            "summary": self.summary,
            "body": self.body,
            "tag": self.tag,
            "gallery": self.gallery,
            "videos": self.videos,
            "awards": self.awards,
            "external_url": self.external_url,
            "order": self.order,
            "featured": self.featured,
            "seo": self.seo,
        }

    # --- rendering ---

    def to_html(
        self,
        env: Environment,
        web_info: "WebsiteInfo",  # type: ignore[name-defined]
        template_path: str = "ulc_project_template_v15.html.j2",
    ) -> str:
        """
        Renders the project to HTML using a Jinja2 template.
        """

        template = env.get_template(template_path)

        # For the template, you might still want just the collaborator names:
        collaborator_names = [
            c.collaborator_info for c in self.collabs if c.collaborator_info
        ]

        html = template.render(
            company_full_name=web_info.company_full_name,
            company_description=web_info.company_description,
            navigation=web_info.navigation,
            main_logo=web_info.main_logo,
            project_title=self.title,
            project_date=self.date,
            project_summary=self.summary,
            videos=self.videos,
            images=self.gallery,
            paragraphs=self.body,
            collaborators=collaborator_names,
            awards=self.awards,
        )
        return html

    def __str__(self) -> str:
        return json.dumps(self.to_dict(), indent=2, ensure_ascii=False)

You can adjust types for awards or body if your CMS returns more structured objects; the skeleton above is aligned structurally with your schema.

---

2. Auto-generating a dataclass from the schema

You can avoid hand-writing a lot of this if your schema is available as a Python dict (e.g. loaded from YAML). For simple fields, you can auto-build a dataclass with make_dataclass.

Here’s a minimal example that:

• Maps type: string/number/boolean/date + list: true to Python types.
• Ignores complex object and reference for now (or treats them as dict / List[dict]).
• Creates the dataclass at runtime.

from __future__ import annotations

from dataclasses import dataclass, field, make_dataclass
from datetime import datetime
from typing import Any, Dict, List, Optional, Type

# Assume this is your schema loaded from YAML (shortened here)
schema: Dict[str, Any] = {
    "fields": [
        {"name": "title", "type": "string", "required": True},
        {"name": "short_title", "type": "string", "required": True},
        {"name": "slug", "type": "string", "required": True},
        {"name": "thumbnail", "type": "image", "required": True},
        {"name": "client", "type": "object"},
        {"name": "collabs", "type": "object", "list": True},
        {"name": "date", "type": "date"},
        {"name": "summary", "type": "text"},
        {"name": "body", "type": "rich-text"},
        {"name": "tag", "type": "string"},
        {"name": "gallery", "type": "image", "options": {"multiple": True}},
        {"name": "videos", "type": "string", "list": True},
        {"name": "awards", "type": "reference", "list": True},
        {"name": "external_url", "type": "string"},
        {"name": "order", "type": "number", "default": 100},
        {"name": "featured", "type": "boolean", "default": False},
        {"name": "seo", "component": "seo"},
    ]
}

def python_type_for_field(f: Dict[str, Any]) -> Type[Any]:
    t = f.get("type") or f.get("component")

    if t in ("string", "text", "rich-text", "image", "reference"):
        base = str
    elif t == "number":
        base = float  # or int, depending on your needs
    elif t == "boolean":
        base = bool
    elif t == "date":
        base = datetime  # or str if you want raw strings
    elif t == "object":
        base = dict
    elif t == "seo":
        base = dict
    else:
        base = Any

    # list: true OR options.multiple
    if f.get("list") or f.get("options", {}).get("multiple"):
        return List[base]  # type: ignore[name-defined]

    return base

def make_dataclass_from_schema(name: str, schema: Dict[str, Any]) -> Type[Any]:
    fields_def = []

    for f in schema["fields"]:
        field_name = f["name"]
        py_type = python_type_for_field(f)
        required = f.get("required", False)

        # Required fields: no default
        if required:
            fields_def.append((field_name, py_type))
        else:
            # Optional fields: Optional[type] + sensible default
            default_value = f.get("default", None)

            # If it's a list type, use default_factory=list
            is_list = (
                f.get("list")
                or f.get("options", {}).get("multiple") is True
            )
            if is_list:
                fields_def.append(
                    (field_name, py_type, field(default_factory=list))
                )
            else:
                fields_def.append(
                    (field_name, Optional[py_type], field(default=default_value))
                )

    # Build the dataclass type dynamically
    return make_dataclass(name, fields_def)

# Usage:
DynamicProject = make_dataclass_from_schema("DynamicProjectV15", schema)

# Now you can do:
p = DynamicProject(
    title="My Project",
    short_title="MyProj",
    slug="my-project",
    thumbnail="thumb.jpg",
)

print(p)

This gives you:

• A runtime dataclass that mirrors your schema’s fields.
• Automatic list defaults for list/multiple fields.
• Optional vs required fields handled based on required.

How far can auto-generation go?

• Straightforward for simple scalar/list fields (string, number, boolean, date).
• Reasonable if you treat object and reference generically as dict/List[dict].
• Very good if you extend the generator to also create nested dataclasses for each type: object definition (e.g. auto-create ClientRef, CollaboratorRef).

If you’d like, I can next:

• Extend the generator so that client and collabs automatically become separate dataclasses based on their nested fields definitions.