Trying cleaner mapping

0.2.x/lib/python/lib-ro-crate-schema/src/lib_ro_crate_schema/crate/rdfs_class.py

@@ -1,6 +1,6 @@
 from typing import List, Literal
 from lib_ro_crate_schema.crate.schema_facade import EQUIVALENT_CLASS, RDFS_SUBCLASS_OF
-from lib_ro_crate_schema.crate.type_property import TypeProperty
+from lib_ro_crate_schema.crate.type_property import TypeProperty, RoTypeProperty
 from lib_ro_crate_schema.crate.ro import RO_ID_LITERAL, RO_TYPE_LITERAL, RoEntity, RoReference
 from pydantic import BaseModel, Field
 
@@ -12,7 +12,7 @@ class RdfsClass(RoEntity):
     self_type: str = Field("rdfs:Class", serialization_alias=RO_TYPE_LITERAL)
     subclass_of: RoReference | List[RoReference] | None = Field(..., serialization_alias=RDFS_SUBCLASS_OF) 
     ontological_annotations: List[str] | None = Field(..., serialization_alias=EQUIVALENT_CLASS)
-    rdfs_properties: List[TypeProperty] | None = None
+    rdfs_properties: List[RoTypeProperty] | None = None
 
 
 

0.2.x/lib/python/lib-ro-crate-schema/src/lib_ro_crate_schema/crate/ro.py

@@ -1,6 +1,6 @@
 from lib_ro_crate_schema.crate.schema_facade import RDFS_CLASS, OWL_RESTRICTION
 from pydantic import BaseModel, Field
-from typing import Literal, Protocol, TypeVar, Generic
+from typing import List, Literal, Protocol, TypeVar, Generic
 
 RO_TYPE_LITERAL = "@type"
 RO_ID_LITERAL = "@id"
@@ -21,6 +21,7 @@ class RoReference(BaseModel):
     id: str = Field(..., serialization_alias=RO_ID_LITERAL)
 
 
+
 class RoEntity(BaseModel):
     """
     This is the base class to represent a RO-Crate graph entity
@@ -40,4 +41,15 @@ class ToRo(Protocol[T]):
     In this way we can for example say that `Type` should implement ToRo[RdfsClass]
     """
     def to_ro(self) -> T:
-        ...
+        ...
+
+type RoReferences = RoReference | List[RoReference] | None
+
+def serialize_references(value: List[str] | str | None) -> RoReferences:
+    match value:
+        case None:
+            return None
+        case str(val) | [val]:
+            return RoReference(id=val)
+        case [vals] as ls:
+            return [RoReference(id=sc) for sc in ls]

0.2.x/lib/python/lib-ro-crate-schema/src/lib_ro_crate_schema/crate/type.py

@@ -3,19 +3,12 @@ from typing import List, Optional, Union
 from lib_ro_crate_schema.crate.rdfs_class import RdfsClass
 from .literal_type import LiteralType
 from .restriction import Restriction
-from .type_property import TypeProperty
-from .ro import RoReference, ToRo
+from .type_property import TypeProperty, RoTypeProperty
+from .ro import RoReference, ToRo, serialize_references
 from pydantic import BaseModel
 
 
-def serialize_subclass_of(value: List[str] | str | None):
-    match value:
-        case None:
-            return None
-        case str(val) | [val]:
-            return RoReference(id=val)
-        case [vals] as ls:
-            return [RoReference(id=sc) for sc in ls]
+
 
 class Type(BaseModel):
     id: str 
@@ -30,8 +23,10 @@ class Type(BaseModel):
     def to_ro(self) -> RdfsClass:
         return RdfsClass(id=self.id, 
                   self_type="rdfs:Class", 
-                  subclass_of=serialize_subclass_of(self.subclass_of),
-                  ontological_annotations=None, rdfs_properties=None)
+                  subclass_of=serialize_references(self.subclass_of),
+                  rdfs_properties=[prop for popr in self.rdfs_property] if self.rdfs_property is not None,
+                  ontological_annotations=None, rdfs_properties=None),
+
         
 
 

0.2.x/lib/python/lib-ro-crate-schema/src/lib_ro_crate_schema/crate/type_property.py

@@ -1,13 +1,40 @@
 from typing import List, Optional, Union
-from .literal_type import LiteralType
-from pydantic import BaseModel
 
+from lib_ro_crate_schema.crate.schema_facade import RDFS_PROPERTY, DOMAIN_IDENTIFIER
+from .literal_type import LiteralType
+from pydantic import BaseModel, Field
+from rocrate.model import Person
+from rocrate.model.contextentity import ContextEntity
+from .ro import RO_ID_LITERAL, RO_TYPE_LITERAL, RoEntity, RoReference, RoReferences, serialize_references
 
 class TypeProperty(BaseModel):
-    id: str
+    id: str = Field(..., serialization_alias=RO_TYPE_LITERAL)
     label: Optional[str] = None
     comment: Optional[str] = None
     domain_includes: Optional[List[str]] = None
     range_includes: Optional[List[str]] = None
     range_includes_data_type: Optional[List[LiteralType]] = None
     ontological_annotations: Optional[List[str]] = None
+
+    def to_ro(self):
+        RoTypeProperty(
+            id = self.id,
+            self_type=RDFS_PROPERTY,
+            label = self.label,
+            comment=self.comment,
+            domain_includes=RoDomain(domain_includes=serialize_references(self.domain_includes))
+        )
+
+class RoDomain(BaseModel):
+    domain_includes: RoReferences = Field(..., serialization_alias=DOMAIN_IDENTIFIER)
+
+class RoTypeProperty(RoEntity):
+    id: str = Field(..., serialization_alias=RO_ID_LITERAL)
+    self_type: str = Field(RDFS_PROPERTY, serialization_alias=RO_TYPE_LITERAL)
+    label: Optional[str] = None
+    comment: Optional[str] = None
+    domain_includes: Optional[List[str]] = None
+    range_includes: Optional[List[str]] = None
+    range_includes_data_type: Optional[List[LiteralType]] = None
+    ontological_annotations: Optional[List[str]] = None
+