feat: property cardinality

Author: mikewolfd

README.md

@@ -31,6 +31,7 @@ While AI assisted in development, all code was reviewed and tested.
 *   **Code Generation:** Creates `msgspec.Struct` definitions from Schema.org types, including type hints and docstrings.
 *   **Proper Inheritance:** Preserves the Schema.org class hierarchy using Python inheritance (`Book` inherits from `CreativeWork`, which inherits from `Thing`).
 *   **JSON-LD Compatibility:** All models support JSON-LD fields (`@id`, `@type`, `@context`) that serialize correctly.
+*   **Property Cardinality:** Implements Schema.org's multiple-value property model, where properties can take both single values and lists of values.
 *   **Category Organization:** Organizes generated classes into subdirectories (CreativeWork, Person, etc.).
 *   **Circular Dependency Resolution:** Uses forward references (`"TypeName"`) and `TYPE_CHECKING` imports.
 *   **Python Compatibility:** Handles reserved keywords.

msgspec_schemaorg/__init__.py

@@ -11,7 +11,7 @@
 - Maintains type safety with modern Python type annotations
 """
 
-__version__ = "0.1.4"
+__version__ = "0.1.5"
 
 # Import the key functions and classes to expose at the package level
 from .generate import fetch_and_generate, SchemaProcessor

msgspec_schemaorg/generate.py

@@ -634,15 +634,18 @@ def generate_struct_code(self, schema_class_id: str) -> tuple[str, list[str]]:
 
             # Create type annotation string
             if len(types) > 1:
-                # Use Union for multiple types
-                type_str = " | ".join(self._get_string_type_annotation(t) for t in types)
+                # Use Union for multiple types, ensuring proper quotes for forward references
+                type_parts = [self._get_string_type_annotation(t) for t in types]
+                type_str = ", ".join(type_parts)
+                # Use Union[] syntax instead of | for compatibility
+                type_str = f"Union[{type_str}]"
             elif len(types) == 1:
                 type_str = self._get_string_type_annotation(types[0])
             else:
                 type_str = "str"  # Default
 
-            # Make all fields optional for now
-            code.append(f"    {prop_name}: {type_str} | None = None")
+            # Add support for multiple values (cardinality) - in Schema.org, properties can have multiple values by default
+            code.append(f"    {prop_name}: Union[List[{type_str}], {type_str}, None] = None")
 
             # Mark if we need date handling
             if has_date_type:
@@ -700,7 +703,15 @@ def _get_string_type_annotation(self, type_obj: Union[type, str]) -> str:
             # Check if it's a Schema.org type (one of our model classes)
             for norm_name in self.normalized_class_names.values():
                 if norm_name == type_obj:
-                    return f"'{type_obj}'"  # Use string literal for all Schema.org types
+                    # Already a string (likely a class name for forward reference)
+                    # Strip quotes if already quoted to prevent double quoting
+                    clean_type = str(type_obj).strip("'\"")
+                    return f"'{clean_type}'"
+            
+            # Handle special case for Union and List types
+            if str(type_obj).startswith(('Union[', 'List[')):
+                return str(type_obj)
+            
             # It's a primitive type or unknown
             return str(type_obj)
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "msgspec-schemaorg"
-version = "0.1.4"
+version = "0.1.5"
 description = "Generate Python msgspec.Struct classes from the Schema.org vocabulary"
 readme = "README.md"
 requires-python = ">=3.10"

tests/test_cardinality.py

@@ -0,0 +1,107 @@
+"""
+Test that Schema.org properties correctly support multiple values (cardinality).
+"""
+import json
+import unittest
+import msgspec
+from pathlib import Path
+
+# This will only work after models are regenerated
+from msgspec_schemaorg.models import Book, Person, CreativeWork
+
+
+class TestCardinality(unittest.TestCase):
+    """Test case for Schema.org property cardinality."""
+
+    def test_single_value(self):
+        """Test that properties work with single values."""
+        # Create a book with a single author
+        author = Person(name="Jane Doe")
+        book = Book(
+            name="The Example",
+            author=author,
+            isbn="123456789X"
+        )
+        
+        # Serialize and deserialize
+        json_data = msgspec.json.encode(book)
+        # Load as dict for checking values
+        data = json.loads(json_data)
+        
+        # Check values
+        self.assertEqual(data["name"], "The Example")
+        self.assertEqual(data["author"]["name"], "Jane Doe")
+        self.assertEqual(data["isbn"], "123456789X")
+    
+    def test_multiple_values(self):
+        """Test that properties work with multiple values (list)."""
+        # Create a book with multiple authors
+        authors = [
+            Person(name="Jane Doe"),
+            Person(name="John Smith")
+        ]
+        
+        book = Book(
+            name="The Co-Authored Example",
+            author=authors,
+            isbn="987654321X"
+        )
+        
+        # Serialize and check the JSON
+        json_data = msgspec.json.encode(book)
+        data = json.loads(json_data)
+        
+        # Check values
+        self.assertEqual(data["name"], "The Co-Authored Example")
+        self.assertEqual(len(data["author"]), 2)
+        self.assertEqual(data["author"][0]["name"], "Jane Doe")
+        self.assertEqual(data["author"][1]["name"], "John Smith")
+        self.assertEqual(data["isbn"], "987654321X")
+    
+    def test_mixed_property_types(self):
+        """Test properties that accept multiple types."""
+        # CreativeWork.about can be any Thing
+        work1 = CreativeWork(name="About a Person", about=Person(name="Subject Person"))
+        work2 = CreativeWork(name="About a Book", about=Book(name="Subject Book"))
+        
+        # Serialize and check
+        json_data1 = msgspec.json.encode(work1)
+        json_data2 = msgspec.json.encode(work2)
+        
+        data1 = json.loads(json_data1)
+        data2 = json.loads(json_data2)
+        
+        # Check values
+        self.assertEqual(data1["about"]["name"], "Subject Person")
+        self.assertEqual(data2["about"]["name"], "Subject Book")
+    
+    def test_mixed_cardinality_and_types(self):
+        """Test properties with both multiple types and multiple values."""
+        # Book can have multiple authors that can be either Person or Organization
+        from msgspec_schemaorg.models import Organization
+        
+        book = Book(
+            name="Complex Example",
+            author=[
+                Person(name="First Author"),
+                Organization(name="Publishing Group"),
+                Person(name="Second Author")
+            ],
+            isbn="555555555X"
+        )
+        
+        # Serialize and check
+        json_data = msgspec.json.encode(book)
+        data = json.loads(json_data)
+        
+        # Check values
+        self.assertEqual(data["name"], "Complex Example")
+        self.assertEqual(len(data["author"]), 3)
+        self.assertEqual(data["author"][0]["name"], "First Author")
+        self.assertEqual(data["author"][1]["name"], "Publishing Group")
+        self.assertEqual(data["author"][2]["name"], "Second Author")
+        self.assertEqual(data["isbn"], "555555555X")
+
+
+if __name__ == "__main__":
+    unittest.main()