gedcom-x 0.5__py3-none-any.whl → 0.5.2__py3-none-any.whl

gedcomx/SourceDescription.py

@@ -9,18 +9,23 @@ from .Agent import Agent
 from .Attribution import Attribution
 from .Coverage import Coverage
 from .Date import Date
-from .Identifier import Identifier
+from .Identifier import Identifier, IdentifierList
 from .Note import Note
 from .SourceCitation import SourceCitation
 from .SourceReference import SourceReference
 from .TextValue import TextValue
+from .Resource import Resource, get_resource_as_dict
+from .Serialization import Serialization
 from .URI import URI
 
+from collections.abc import Sized
+
 class ResourceType(Enum):
     Collection = "http://gedcomx.org/Collection"
     PhysicalArtifact = "http://gedcomx.org/PhysicalArtifact"
     DigitalArtifact = "http://gedcomx.org/DigitalArtifact"
     Record = "http://gedcomx.org/Record"
+    Person = "http://gedcomx.org/Person"    
     
     @property
     def description(self):
@@ -33,26 +38,49 @@ class ResourceType(Enum):
         return descriptions.get(self, "No description available.")
     
 class SourceDescription:
+    """
+    The SourceDescription data type defines a description of a source of genealogical information.
+    http://gedcomx.org/v1/SourceDescription
+
+    Parameters
+    ----------
+    id : str
+        Unique identifier for this SourceDescription.
+    attribution : Attribution Object
+        Attribution information for the Genealogy
+    filepath : str
+        Not Implimented.
+    description : str
+        Description of the Genealogy: ex. 'My Family Tree'
+
+    Raises
+    ------
+    ValueError
+        If `id` is not a valid UUID.
+    """
     identifier = "http://gedcomx.org/v1/SourceDescription"
+    """
+    Gedcom-X Specification Identifier
+    """
 
     def __init__(self, id: Optional[str] = None,
                  resourceType: Optional[ResourceType] = None,
                  citations: Optional[List[SourceCitation]] = [],
                  mediaType: Optional[str] = None,
                  about: Optional[URI] = None,
-                 mediator: Optional[URI] = None,
-                 publisher: Optional[URI] = None,
-                 authors: Optional[List[URI]] = [],
-                 sources: List[SourceReference] = [], # SourceReference
-                 analysis: Optional[URI] = None,  # analysis should be of type 'Document', not specified to avoid circular import
+                 mediator: Optional[Resource] = None,
+                 publisher: Optional[Resource|Agent] = None,
+                 authors: Optional[List[Resource]] = None,
+                 sources: Optional[List[SourceReference]] = None, # SourceReference
+                 analysis: Optional[Resource] = None,  # analysis should be of type 'Document', not specified to avoid circular import
                  componentOf: Optional[SourceReference] = None, # SourceReference
-                 titles: Optional[List[TextValue]] = [],
-                 notes: Optional[List[Note]] = [],
+                 titles: Optional[List[TextValue]] = None,
+                 notes: Optional[List[Note]] = None,
                  attribution: Optional[Attribution] = None,
-                 rights: Optional[List[URI]] = [],
+                 rights: Optional[List[Resource]] = [],
                  coverage: Optional[Coverage] = None, # Coverage
-                 descriptions: Optional[List[TextValue]] = [],
-                 identifiers: Optional[List[Identifier]] = [],
+                 descriptions: Optional[List[TextValue]] = None,
+                 identifiers: Optional[IdentifierList] = None,
                  created: Optional[Date] = None,
                  modified: Optional[Date] = None,
                  published: Optional[Date] = None,
@@ -65,9 +93,9 @@ class SourceDescription:
         self.mediaType = mediaType
         self.about = about
         self.mediator = mediator
-        self.publisher = publisher
+        self._publisher = publisher 
         self.authors = authors or []
-        self.source_refs = sources or []
+        self.sources = sources or []
         self.analysis = analysis
         self.componentOf = componentOf
         self.titles = titles or []
@@ -76,14 +104,30 @@ class SourceDescription:
         self.rights = rights or []
         self.coverage = coverage or []
         self.descriptions = descriptions or []
-        self.identifiers = identifiers or []
+        self.identifiers = identifiers or IdentifierList()
         self.created = created
         self.modified = modified
         self.published = published
         self.repository = repository
         self.max_note_count = max_note_count
 
-        self._uri = URI(fragment=id)
+        self.uri = URI(fragment=id)
+    
+    @property
+    def publisher(self) -> Resource | Agent | None:
+        return self._publisher
+    
+
+    @publisher.setter
+    def publisher(self, value: Resource | Agent):
+        if value is None:
+            self._publisher = None
+        elif isinstance(value,Resource):
+            self._publisher = value
+        elif isinstance(value,Agent):
+            self._publisher = value
+        else:
+            raise ValueError(f"'publisher' must be of type 'URI' or 'Agent', type: {type(value)} was provided")
     
     def add_description(self, desccription_to_add: TextValue):
         if desccription_to_add and isinstance(desccription_to_add,TextValue):
@@ -94,9 +138,6 @@ class SourceDescription:
 
     def add_identifier(self, identifier_to_add: Identifier):
         if identifier_to_add and isinstance(identifier_to_add,Identifier):
-            for current_identifier in self.identifiers:
-                if identifier_to_add == current_identifier:
-                    return
             self.identifiers.append(identifier_to_add)
     
     def add_note(self,note_to_add: Note):
@@ -139,51 +180,40 @@ class SourceDescription:
     
     @property
     def _as_dict_(self) -> Dict[str, Any]:
-        def _serialize(val: Any) -> Any:
-            if hasattr(val, '_as_dict_'):
-                return val._as_dict_
-            if isinstance(val, URI):
-                return val._prop_dict()
-            if isinstance(val, Enum):
-                return val.value
-            if isinstance(val, (str, int, float, bool)) or val is None:
-                return val
-            if isinstance(val, list):
-                return [_serialize(v) for v in val]
-            if isinstance(val, dict):
-                return {k: _serialize(v) for k, v in val.items()}
-            return str(val)
+        
 
-        data = {
+        
+        type_as_dict = {
             'id': self.id,
+            'about': self.about._as_dict_ if self.about else None,
             'resourceType': self.resourceType.value if self.resourceType else None,
             'citations': [c._as_dict_ for c in self.citations] or None,
             'mediaType': self.mediaType,
-            'about': self.about._prop_dict() if self.about else None,
-            'mediator': self.mediator._prop_dict() if self.mediator else None,
-            'publisher': self.publisher._prop_dict() if self.publisher else None,
-            'authors': [a._prop_dict() for a in self.authors] or None,
+            'mediator': get_resource_as_dict(self.mediator),
+            'publisher': get_resource_as_dict(self.publisher),
+            'authors': [get_resource_as_dict(a) for a in self.authors] or None,
             'sources': [s._as_dict_ for s in self.sources] or None,
-            'analysis': self.analysis._prop_dict() if self.analysis else None,
+            'analysis': self.analysis._as_dict_ if self.analysis else None,
             'componentOf': self.componentOf._as_dict_ if self.componentOf else None,
-            'titles': [t._prop_dict() for t in self.titles] or None,
-            'notes': [n._prop_dict() for n in self.notes] or None,
+            'titles': [t._as_dict_ for t in self.titles] or None,
+            'notes': [n._as_dict_ for n in self.notes] or None,
             'attribution': self.attribution._as_dict_ if self.attribution else None,
-            'rights': [r._prop_dict() for r in self.rights] or None,
+            'rights': [r._as_dict_ for r in self.rights] or None,
             'coverage': self.coverage._as_dict_ if self.coverage else None,
-            'descriptions': [d._prop_dict() for d in self.descriptions] or None,
-            'identifiers': [i._as_dict_ for i in self.identifiers] or None,
-            'created': self.created._prop_dict() if self.created else None,
-            'modified': self.modified._prop_dict() if self.modified else None,
-            'published': self.published._prop_dict() if self.published else None,
-            'repository': self.repository._prop_dict() if self.repository else None
+            'descriptions': [d._as_dict_ for d in self.descriptions] or None,
+            'identifiers': self.identifiers._as_dict_ if self.identifiers else None,
+            'created': self.created if self.created else None,
+            'modified': self.modified if self.modified else None,
+            'published': self.published if self.published else None,
+            'repository': get_resource_as_dict(self.repository),
+            'uri': self.uri.value
         }
-        # Remove None values
-        return {k: v for k, v in data.items() if v is not None}
-    
+        
+        return Serialization.serialize_dict(type_as_dict)
+         
+            
     @classmethod
     def _from_json_(cls, data: Dict[str, Any]) -> 'SourceDescription':
-        print(data,type(data))
         # TODO Hande Resource/URI
         
         # Basic fields
@@ -193,11 +223,11 @@ class SourceDescription:
         # Sub-objects
         citations    = [SourceCitation._from_json_(c) for c in data.get('citations', [])]
         about        = URI._from_json_(data['about']) if data.get('about') else None
-        mediator     = URI._from_json_(data['mediator']) if data.get('mediator') else None
-        publisher    = Agent._from_json_(data['publisher']) if data.get('publisher') else None
-        authors      = [URI._from_json_(a) for a in data.get('authors', [])]
+        mediator     = Resource._from_json_(data['mediator']) if data.get('mediator') else None
+        publisher    = Resource._from_json_(data['publisher']) if data.get('publisher') else None
+        authors      = [Resource._from_json_(a) for a in data.get('authors', [])]
         sources      = [SourceReference._from_json_(s) for s in data.get('sources', [])]
-        analysis     = URI._from_json_(data['analysis']) if data.get('analysis') else None
+        analysis     = Resource._from_json_(data['analysis']) if data.get('analysis') else None
         component_of = SourceReference._from_json_(data['componentOf']) if data.get('componentOf') else None
         titles       = [TextValue._from_json_(t) for t in data.get('titles', [])]
         notes        = [Note._from_json_(n) for n in data.get('notes', [])]
@@ -205,9 +235,10 @@ class SourceDescription:
         rights       = [URI._from_json_(r) for r in data.get('rights', [])]
         coverage     = [Coverage._from_json_(cvg) for cvg in data.get('coverage',[])] 
         descriptions = [TextValue._from_json_(d) for d in data.get('descriptions', [])]
-        identifiers  = [Identifier._from_json_(i) for i in data.get('identifiers', [])]
+        identifiers  = IdentifierList._from_json_(data.get('identifiers', []))
+        
         created      = Date._from_json_(data['created']) if data.get('created') else None
-        modified     = Date._from_json_(data['modified']) if data.get('modified') else None
+        modified     = data.get('modified',None)
         published    = Date._from_json_(data['published']) if data.get('published') else None
         repository   = Agent._from_json_(data['repository']) if data.get('repository') else None
 
@@ -224,18 +255,4 @@ class SourceDescription:
             published=published, repository=repository
         )
 
-    @property
-    def publisher(self) -> URI:
-        if not self._publisher is None or isinstance(self._publisher,URI): assert False
-        return self._publisher
-
-    @publisher.setter
-    def publisher(self, value: URI | Agent):
-        if value is None:
-            self._publisher = None
-        elif isinstance(value,URI):
-            assert False
-        elif isinstance(value,Agent):
-            self._publisher = value._uri
-        else:
-            raise ValueError(f"'publisher' must be of type 'URI' or 'Agent', type: {type(value)} was provided")
+    

gedcomx/SourceReference.py

@@ -3,8 +3,11 @@ from typing import List, Optional
 from .Attribution import Attribution
 from .Qualifier import Qualifier
 
+from .Resource import Resource
 from .URI import URI
 
+from collections.abc import Sized
+
 class KnownSourceReference(Qualifier):
     CharacterRegion = "http://gedcomx.org/CharacterRegion"
     RectangleRegion = "http://gedcomx.org/RectangleRegion"
@@ -42,13 +45,16 @@ class KnownSourceReference(Qualifier):
 class SourceReference:
     identifier = 'http://gedcomx.org/v1/SourceReference'
     version = 'http://gedcomx.org/conceptual-model/v1'
-
+    
     def __init__(self,
-                 description: URI, descriptionId: Optional[str] = None, attribution: Optional[Attribution] = None, qualifiers: Optional[List[Qualifier]] = []) -> None:
+                 description: URI | object | None = None,
+                 descriptionId: Optional[str] = None,
+                 attribution: Optional[Attribution] = None,
+                 qualifiers: Optional[List[Qualifier]] = None
+                 ) -> None:
         
         #if not isinstance(description,URI): raise ValueError(f"description is of type {type(description)}")
-
-        from .SourceDescription import SourceDescription
+        '''from .SourceDescription import SourceDescription
         self._description_object = None
         if isinstance(description,URI):
             #TODO See if Local, If not try to resolve,
@@ -60,13 +66,14 @@ class SourceReference:
                 self.description = description._uri
             else:
                 assert False
-                self.description = URI(object=description)
+                self.description = Resource(object=description)
                 description._uri = self.description
                 description._object = description
         else:
-            raise ValueError(f"'description' must be of type 'SourceDescription' or 'URI', type: {type(description)} was provided")
+            raise ValueError(f"'description' must be of type 'SourceDescription' or 'URI', type: {type(description)} was provided")'''
         
-        #self.description = description
+        
+        self.description = description
         self.descriptionId = descriptionId
         self.attribution = attribution
         self.qualifiers = qualifiers
@@ -101,9 +108,9 @@ class SourceReference:
 
         # Only add Relationship-specific fields
         sourcereference_fields = {
-            'description':self._description_object._uri if self._description_object else None,
+            'description':self.description.uri if self.description else None,
             'descriptionId': self.descriptionId.replace("\n"," ").replace("\r"," ") if self.descriptionId else None,
-            'attribution': self.attribution if self.attribution else None,
+            'attribution': self.attribution._as_dict_ if self.attribution else None,
             'qualifiers':[qualifier.value for qualifier in self.qualifiers ] if self.qualifiers else None
             }
 
@@ -112,12 +119,16 @@ class SourceReference:
             if value is not None:
                 sourcereference_fields[key] = _serialize(value)
 
-        return sourcereference_fields
+        return {
+            k: v
+            for k, v in sourcereference_fields.items()
+            if v is not None and not (isinstance(v, Sized) and len(v) == 0)
+        }
+        
 
     @classmethod
     def _from_json_(cls, data: dict):
-        print(data)
-        
+                
         """
         Rehydrate a SourceReference from the dict form produced by _as_dict_.
         """
@@ -128,7 +139,7 @@ class SourceReference:
         #if not desc_json:
         #    raise ValueError("SourceReference JSON missing 'description'")
         #desc_obj = SourceDescription._from_json_(desc_json)
-        desc_obj = URI.from_url(data.get('description')) #TODO <--- URI Reference
+        desc_obj = URI.from_url_(data.get('description')) #TODO <--- URI Reference
         
 
         # 2) Simple fields
@@ -164,5 +175,5 @@ class SourceReference:
             return False  
 
         return (
-            self.description._uri == other.description._uri
+            self.description.uri == other.description.uri
         )

gedcomx/Subject.py

@@ -4,11 +4,12 @@ from typing import List, Optional
 from .Attribution import Attribution
 from .Conclusion import Conclusion, ConfidenceLevel
 from .EvidenceReference import EvidenceReference
-from .Identifier import Identifier
+from .Identifier import Identifier, IdentifierList
 from .Note import Note
-from .Serialization import serialize_to_dict
+from .Serialization import Serialization
 from .SourceReference import SourceReference
-from .URI import URI
+from .Resource import Resource
+from ._Links import _LinkList
 
 class Subject(Conclusion):
     identifier = 'http://gedcomx.org/v1/Subject'
@@ -18,16 +19,17 @@ class Subject(Conclusion):
                  id: Optional[str],
                  lang: Optional[str] = 'en',
                  sources: Optional[List[SourceReference]] = [],
-                 analysis: Optional[URI] = None,
+                 analysis: Optional[Resource] = None,
                  notes: Optional[List[Note]] = [],
                  confidence: Optional[ConfidenceLevel] = None,
                  attribution: Optional[Attribution] = None,
                  extracted: Optional[bool] = None,
                  evidence: Optional[List[EvidenceReference]] = [],
                  media: Optional[List[SourceReference]] = [],
-                 identifiers: Optional[List[Identifier]] = [],
-                 uri: Optional[URI] = None) -> None:
-        super().__init__(id, lang, sources, analysis, notes, confidence, attribution)
+                 identifiers: Optional[IdentifierList] = None,
+                 uri: Optional[Resource] = None,
+                 links: Optional[_LinkList] = None) -> None:
+        super().__init__(id, lang, sources, analysis, notes, confidence, attribution,links=links)
         self.extracted = extracted
         self.evidence = evidence
         self.media = media
@@ -61,7 +63,7 @@ class Subject(Conclusion):
             "extracted": self.extracted,
             "evidence": [evidence_ref for evidence_ref in self.evidence] if self.evidence else None,
             "media": [media for media in self.media] if self.media else None,
-            "identifiers": [identifier for identifier in self.identifiers] if self.identifiers else None
+            "identifiers": self.identifiers._as_dict_ if self.identifiers else None
                            
         })
 

gedcomx/TextValue.py

@@ -13,7 +13,8 @@ class TextValue:
             raise ValueError(f"Cannot append object of type {type(value_to_append)}.")
         self.value += ' ' + value_to_append
     
-    def _prop_dict(self):
+    @property
+    def _as_dict_(self):
         return {
             "lang":self.lang if self.lang else None,
             "value":self.value if self.value else None

gedcomx/URI.py

@@ -1,70 +1,104 @@
-from typing import Optional
-from urllib.parse import urlparse
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Mapping, Optional, Union, Iterable, Tuple
+from urllib.parse import urlsplit, urlunsplit, urlencode, parse_qsl, SplitResult
 
+_DEFAULT_SCHEME = "gedcomx"
+
+@dataclass(frozen=False, slots=True)
 class URI:
-    @classmethod
-    def from_url(cls, url: str) -> 'URI':
-        parsed_url = urlparse(url)
-        return cls(
-            value=url,
-            scheme=parsed_url.scheme if parsed_url.scheme else 'gedcomx',
-            authority=parsed_url.netloc,
-            path=parsed_url.path,
-            query=parsed_url.query,
-            fragment=parsed_url.fragment
-        )
-    
-    def parse(value: str) -> None:
-        """Parse the URI string and populate attributes."""
-        parsed = urlparse(value)
-        return URI(scheme=parsed.scheme,authority = parsed.netloc, path = parsed.path, query = parsed.query, fragment = parsed.fragment)
-        
+    scheme: str = field(default=_DEFAULT_SCHEME)
+    authority: str = field(default="")
+    path: str = field(default="")
+    query: str = field(default="")
+    fragment: str = field(default="")
 
-    def __init__(self, value: Optional[str] = None,
-                 scheme: Optional[str] = None,
-                 authority: Optional[str] = None,
-                 path: Optional[str] = None,
-                 query: Optional[str] = None,
-                 fragment: Optional[str] = None,
-                 object = None) -> None:
-        
-        self._scheme = scheme if scheme else 'gedcomx'
-        self._authority = authority
-        self._path = path
-        self._query = query
-        self._fragment = fragment
-        self._object = None
+    # ---------- constructors ----------
+    @classmethod
+    def from_url(cls, url: str, *, default_scheme: str = _DEFAULT_SCHEME) -> "URI":
+        s = urlsplit(url)
+        scheme = s.scheme or default_scheme
+        return cls(scheme=scheme, authority=s.netloc, path=s.path, query=s.query, fragment=s.fragment)
 
-        if object is not None:
-            self._object = object
-            if hasattr(object,'_uri'):
-                self._object._uri = self
+    @classmethod
+    def parse(cls, value: str) -> "URI":
+        return cls.from_url(value)
 
+    @classmethod
+    def from_parts(
+        cls,
+        *,
+        scheme: Optional[str] = None,
+        authority: str = "",
+        path: str = "",
+        query: Union[str, Mapping[str, str], Iterable[Tuple[str, str]]] = "",
+        fragment: str = ""
+    ) -> "URI":
+        q = query if isinstance(query, str) else urlencode(query, doseq=True)
+        return cls(scheme=scheme or _DEFAULT_SCHEME, authority=authority, path=path, query=q, fragment=fragment)
 
+    # ---------- views ----------
     @property
-    def _uri(self) -> str:
-        uri = ""
-        if self._scheme:
-            uri += f"{self._scheme}://"
-        if self._authority:
-            uri += f"{self._authority}/"
-        if self._path:
-            uri += f"{self._path}/"
-        if self._query:
-            uri += f"?{self._query}"
-        if self._fragment:
-            uri += f"#{self._fragment}"
-        return uri
-    
-    @property
-    def value(self):
-        return self._uri
-    
+    def value(self) -> str:
+        return str(self)
+
+    def split(self) -> SplitResult:
+        return SplitResult(self.scheme, self.authority, self.path, self.query, self.fragment)
+
+    def __str__(self) -> str:
+        return urlunsplit(self.split())
+
     @property
-    def _as_dict_(self):
-        return {"Resource":self._uri}
-    
-    
+    def _as_dict_(self) -> dict:
+        # Keeps a simple, explicit structure
+        return {
+            "scheme": self.scheme,
+            "authority": self.authority,
+            "path": self.path,
+            "query": self.query,
+            "fragment": self.fragment,
+            "value": str(self),
+        }
+
+    # Accepts {'resource': '...'} or a plain string, mirroring your original
     @classmethod
-    def _from_json_(obj,text):
-        return URI(scheme='NEED TO DEAL WITH URI')
+    def from_jsonish(cls, data: Union[str, Mapping[str, str]]) -> "URI":
+        if isinstance(data, str):
+            return cls.from_url(data)
+        if isinstance(data, Mapping):
+            raw = data.get("resource") or data.get("value") or ""
+            if raw:
+                return cls.from_url(raw)
+        raise ValueError(f"Cannot build URI from: {data!r}")
+
+    # ---------- functional updaters ----------
+    def with_scheme(self, scheme: str) -> "URI": return self.replace(scheme=scheme)
+    def with_authority(self, authority: str) -> "URI": return self.replace(authority=authority)
+    def with_path(self, path: str, *, join: bool = False) -> "URI":
+        new_path = (self.path.rstrip("/") + "/" + path.lstrip("/")) if join else path
+        return self.replace(path=new_path)
+    def with_fragment(self, fragment: str | None) -> "URI":
+        return self.replace(fragment=(fragment or ""))
+    def without_fragment(self) -> "URI": return self.replace(fragment="")
+    def with_query(self, query: Union[str, Mapping[str, str], Iterable[Tuple[str, str]]]) -> "URI":
+        q = query if isinstance(query, str) else urlencode(query, doseq=True)
+        return self.replace(query=q)
+    def add_query_params(self, params: Mapping[str, Union[str, Iterable[str]]]) -> "URI":
+        existing = parse_qsl(self.query, keep_blank_values=True)
+        for k, v in params.items():
+            if isinstance(v, str):
+                existing.append((k, v))
+            else:
+                for vv in v:
+                    existing.append((k, vv))
+        return self.replace(query=urlencode(existing, doseq=True))
+
+    # ---------- helpers ----------
+    def replace(self, **kwargs) -> "URI":
+        return URI(
+            scheme=kwargs.get("scheme", self.scheme or _DEFAULT_SCHEME),
+            authority=kwargs.get("authority", self.authority),
+            path=kwargs.get("path", self.path),
+            query=kwargs.get("query", self.query),
+            fragment=kwargs.get("fragment", self.fragment),
+        )

gedcomx/Zip.py

@@ -0,0 +1 @@
+import zipfile

gedcomx/_Links.py

@@ -0,0 +1,37 @@
+from typing import List, Optional
+
+class _Link():
+    def __init__(self,category: str, key_val_pairs:  dict) -> None:
+        self._category = category
+        self._kvps: dict = key_val_pairs if key_val_pairs else {}
+    
+    def _add_kvp(self, key, value):
+        pass
+
+class _LinkList():
+    def __init__(self) -> None:
+        self.links = {}
+
+    def add(self,link: _Link):
+        if link and isinstance(link,_Link):
+            if link._category in self.links.keys():
+                self.links[link._category].append(link._kvps)
+            else:
+                self.links[link._category] = [link._kvps]
+        
+
+    @classmethod
+    def _from_json_(cls,data: dict):
+        
+        link_list = _LinkList()
+        for category in data.keys():
+            link_list.add(_Link(category,data[category]))
+        
+        return link_list
+    
+    @property
+    def _as_dict_(self) -> dict:
+        return self.links
+
+
+        

gedcomx/__init__.py

@@ -17,7 +17,8 @@ from .Gedcom import Gedcom
 from .GedcomX import GedcomX, Translater
 from .Gender import Gender, GenderType
 from .Group import Group, GroupRole
-from .Identifier import Identifier, IdentifierType
+from .Identifier import Identifier, IdentifierType, IdentifierList
+from .Logging import get_logger
 from .Name import Name, NameForm, NamePart, NamePartType, NameType, NamePartQualifier
 from .Note import Note
 from .OnlineAccount import OnlineAccount
@@ -26,13 +27,14 @@ from .PlaceDescription import PlaceDescription
 from .PlaceReference import PlaceReference
 from .Qualifier import Qualifier
 from .Relationship import Relationship, RelationshipType
-from .Serialization import serialize_to_dict
+from .Serialization import Serialization
 from .SourceCitation import SourceCitation
 from .SourceDescription import SourceDescription
 from .SourceDescription import ResourceType
 from .SourceReference import SourceReference
 from .Subject import Subject
 from .TextValue import TextValue
+from .Resource import Resource
 from .URI import URI