test ld models

Author: phenobarbital

datamodel/base.py

@@ -1,9 +1,10 @@
 from collections.abc import Callable
-from typing import Any
+from typing import Any, Dict
 # Dataclass
 from dataclasses import (
     _FIELD,
 )
+from html import escape
 from .converters import process_attributes, register_converter
 from .fields import Field
 from .exceptions import ValidationError
@@ -13,6 +14,19 @@
 
 TYPE_CONVERTERS = {}
 
+RendererFn = Callable[["BaseModel", bool], str]
+
+HTML_RENDERERS: Dict[str, RendererFn] = {}
+
+def register_renderer(schema_type: str):
+    """
+    Decorator to register a custom renderer function for a given schema_type.
+    """
+    def decorator(fn: RendererFn):
+        HTML_RENDERERS[schema_type] = fn
+        return fn
+    return decorator
+
 
 class BaseModel(ModelMixin, metaclass=ModelMeta):
     """
@@ -103,3 +117,70 @@ def set(self, name: str, value: Any) -> None:
 
     def get_errors(self):
         return self.__errors__
+
+    def to_html(self, top_level: bool = True) -> str:
+        """to_html.
+        Convert Model to HTML.
+
+        Args:
+            top_level (bool, optional): If True, adds the @context to the schema.
+        """
+        # 1) Determine the schema type from self.Meta or fallback to class name
+        schema_type = getattr(self.Meta, 'schema_type', self.__class__.__name__)
+
+        if schema_type in HTML_RENDERERS:
+            return HTML_RENDERERS[schema_type](self, top_level)
+
+        # 2) Container opening. For top-level objects, we specify:
+        #    - vocab="https://schema.org/"
+        #    - typeof="Recipe" (or other type)
+        #    For nested objects, we might omit the 'vocab' attribute
+        #    or rely on the parent's scope.
+        if top_level:
+            container_open = f'<div vocab="https://schema.org/" typeof="{escape(schema_type)}">'
+        else:
+            container_open = f'<div property="{escape(schema_type)}" typeof="{escape(schema_type)}">'
+
+        # We'll accumulate our HTML pieces here
+        pieces = [container_open]
+
+        # 3) Iterate over each field in this model
+        for field_name, value in self.__dict__.items():
+            # Skip internal or error fields
+            if field_name.startswith('_') or field_name == '__errors__':
+                continue
+
+            # Optionally skip if None
+            if value is None:
+                continue
+
+            # 4) If value is a nested model, convert it to HTML as well
+            if isinstance(value, BaseModel):
+                nested_html = value.to_html(False)
+                snippet = f'<div property="{escape(field_name)}">\n{nested_html}\n</div>'
+                pieces.append(snippet)
+
+            elif isinstance(value, list):
+                # We might iterate and produce multiple lines
+                for item in value:
+                    if isinstance(item, BaseModel):
+                        nested_html = item.to_html(False)
+                        snippet = f'<div property="{escape(field_name)}">\n{nested_html}\n</div>'
+                        pieces.append(snippet)
+                    else:
+                        # If it's a simple scalar, just output a <span>
+                        # e.g.: <span property="recipeIngredient">3 bananas</span>
+                        val_escaped = escape(str(item))
+                        snippet = f'<span property="{escape(field_name)}">{val_escaped}</span>'
+                        pieces.append(snippet)
+            else:
+                # For simple scalars (str, int, etc.):
+                # We might choose <span> or <meta> based on type.
+                # We'll do something simple: a <span>
+                val_escaped = escape(str(value))
+                snippet = f'<span property="{escape(field_name)}">{val_escaped}</span>'
+                pieces.append(snippet)
+
+        # 4) Close the container
+        pieces.append('</div>')
+        return "\n".join(pieces)

datamodel/jsonld/__init__.py

@@ -14,7 +14,11 @@
     Review,
     VideoObject,
     AdministrativeArea,
-    Audience
+    Audience,
+    Place,
+    QuantitativeValue,
+    MonetaryAmount,
+    JobPosting,
 )
 
 JSON_MODEL_MAP = {
@@ -33,5 +37,9 @@
     "Review": Review,
     "VideoObject": VideoObject,
     "AdministrativeArea": AdministrativeArea,
-    "Audience": Audience
+    "Audience": Audience,
+    "Place": Place,
+    "QuantitativeValue": QuantitativeValue,
+    "MonetaryAmount": MonetaryAmount,
+    "JobPosting": JobPosting,
 }

datamodel/jsonld/models.py

@@ -1,6 +1,7 @@
 from typing import Any, List, Optional, Union
+from html import escape
 from datetime import datetime
-from ..base import BaseModel, Field
+from ..base import BaseModel, Field, register_renderer
 
 
 class URL(BaseModel):
@@ -120,6 +121,7 @@ class ImageObject(BaseModel):
     Corresponds to the JSON-LD "ImageObject" type.
     https://schema.org/ImageObject
     """
+    name: str
     url: str = Field(required=True)
     width: int = 0
     height: int = 0
@@ -362,3 +364,137 @@ class Audience(BaseModel):
 
     class Meta:
         schema_type: str = "Audience"
+
+
+class Place(BaseModel):
+    address: PostalAddress
+
+    class Meta:
+        schema_type = "Place"
+
+class QuantitativeValue(BaseModel):
+    value: float
+    unitText: str
+
+    class Meta:
+        schema_type = "QuantitativeValue"
+
+class MonetaryAmount(BaseModel):
+    currency: Union[str, float]
+    value: QuantitativeValue
+
+    class Meta:
+        schema_type = "MonetaryAmount"
+
+class JobPosting(BaseModel):
+    title: str
+    description: str
+    hiringOrganization: Organization
+    datePosted: str
+    validThrough: str
+    jobLocation: Optional[Place]
+    baseSalary: Optional[MonetaryAmount]
+    qualifications: str
+    skills: List[str]
+    responsibilities: str
+    educationRequirements: str
+    experienceRequirements: str
+
+    class Meta:
+        schema_type = "JobPosting"
+
+
+@register_renderer("ImageObject")
+def render_imageobject(model: "BaseModel", top_level: bool) -> str:
+    """
+    Render an ImageObject in a custom way:
+      <div typeof="ImageObject">
+        <h2 property="name">...</h2>
+        <img src="..." alt="..." property="contentUrl"/>
+        ...
+      </div>
+    """
+    # You can read fields from the model (like name, url, caption, etc.).
+    # If you used 'url' as the field that is the image's src, we can do:
+    name = getattr(model, "name", None)  # or None if not present
+    url = getattr(model, "url", None)
+    caption = getattr(model, "caption", None)
+    width = getattr(model, "width", None)
+    height = getattr(model, "height", None)
+
+    schema_type = getattr(model.Meta, 'schema_type', model.__class__.__name__)
+
+    container_open = ""
+    if top_level:
+        container_open = f'<div vocab="https://schema.org/" typeof="{escape(schema_type)}">'  # noqa
+    else:
+        # when nested, we might do property="image" or property=schema_type
+        container_open = f'<div property="{escape(schema_type)}" typeof="{escape(schema_type)}">'  # noqa
+
+    pieces = [container_open]
+
+    # Render name as <h2 property="name">Name</h2> if present
+    if name:
+        name_esc = escape(str(name))
+        pieces.append(f'<h2 property="name">{name_esc}</h2>')
+
+    # Now create an <img> that has property="contentUrl" or "url"
+    if url:
+        url_esc = escape(str(url))
+        caption_esc = escape(str(caption or ""))
+        # alt can come from caption
+        snippet = f'<img property="contentUrl" src="{url_esc}" alt="{caption_esc}"'
+        if width:
+            snippet += f' width="{escape(str(width))}"'
+        if height:
+            snippet += f' height="{escape(str(height))}"'
+        snippet += ' />'
+        pieces.append(snippet)
+
+    # If we have other fields not individually handled, we could do a fallback
+    # to the normal field iteration. But for brevity, let's omit that here.
+    # E.g. leftover = model.render_remaining_fields(…)
+    # pieces.append(leftover)
+
+    pieces.append('</div>')
+    return "\n".join(pieces)
+
+
+@register_renderer("GeoCoordinates")
+def render_geocoordinates(model: "BaseModel", top_level: bool) -> str:
+    """
+    Custom renderer for GeoCoordinates:
+      <div property="geo" typeof="GeoCoordinates">
+          <meta property="latitude" content="40.75"/>
+          <meta property="longitude" content="-73.98"/>
+          ...
+      </div>
+    """
+    lat = getattr(model, "latitude", None)
+    lng = getattr(model, "longitude", None)
+    elevation = getattr(model, "elevation", None)
+
+    schema_type = getattr(model.Meta, 'schema_type', model.__class__.__name__)
+    if top_level:
+        container_open = f'<div vocab="https://schema.org/" typeof="{escape(schema_type)}">'  # noqa
+    else:
+        container_open = f'<div property="{escape(schema_type)}" typeof="{escape(schema_type)}">'  # noqa
+
+    pieces = [container_open]
+
+    # For numeric fields, we might prefer <meta ... content="..."/>
+    if lat is not None:
+        pieces.append(
+            f'<meta property="latitude" content="{escape(str(lat))}" />'
+        )
+    if lng is not None:
+        pieces.append(
+            f'<meta property="longitude" content="{escape(str(lng))}" />'
+        )
+    if elevation is not None:
+        pieces.append(
+            f'<meta property="elevation" content="{escape(str(elevation))}" />'
+        )
+
+    pieces.append('</div>')
+    return "\n".join(pieces)

examples/test_ld_creation.py

@@ -1,3 +1,6 @@
+
+from datamodel.jsonld.models import ImageObject
+
 data = """
 {
 		"@context": "http://schema.org",
@@ -255,3 +258,7 @@
 		}
 	}
 """  # noqa
+
+
+img = ImageObject(name="a Mexico Beach", url="mexico-beach.jpg", caption="Sunny, sandy beach.")
+print(img.to_html(top_level=True))