U/gblackadder/private types (#14)

* fix warnings on schema private attrbs

* fix two typos elctronicMailAddress -> electronicMailAddress FormatDistributor -> formatDistributor

pydantic_schemas/document_schema.py

@@ -595,8 +595,8 @@ class ScriptSchemaDraft(SchemaBaseModel):
     """
     Schema for Document data type
     """
-    __metadata_type__ = "document"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "document"
+    _metadata_type_version__ = "0.1.0" 
 
     idno: Optional[str] = Field(
         None, description="Project unique identifier", title="Project unique identifier"

pydantic_schemas/generators/generate_pydantic_schemas.py

@@ -59,7 +59,7 @@
         lambda match,
         model_name=model_name,
         section=section,
-        version=version: f"""class {model_name}(SchemaBaseModel):\n{match.group(1)}\n    __metadata_type__ = "{section}"\n    __metadata_type_version__ = "{version}" """,
+        version=version: f"""class {model_name}(SchemaBaseModel):\n{match.group(1)}\n    _metadata_type__ = "{section}"\n    _metadata_type_version__ = "{version}" """,
         content,
     )
 

pydantic_schemas/geospatial_schema.py

@@ -636,7 +636,7 @@ class Address(SchemaBaseModel):
     city: Optional[str] = Field(None, title="City")
     postalCode: Optional[str] = Field(None, title="Postal Code")
     country: Optional[str] = Field(None, title="Country")
-    elctronicMailAddress: Optional[str] = Field(None, title="Email")
+    electronicMailAddress: Optional[str] = Field(None, title="Email")
 
 
 class ContactInfo(SchemaBaseModel):
@@ -837,7 +837,7 @@ class Format(SchemaBaseModel):
     fileDecompressionTechnique: Optional[str] = Field(
         None, title="File decompression technique"
     )
-    FormatDistributor: Optional[ResponsibleParty] = Field(
+    formatDistributor: Optional[ResponsibleParty] = Field(
         None,
         description="Responsible party in charge of the format distribution",
         title="Distributor",
@@ -1513,8 +1513,8 @@ class GeospatialSchema(SchemaBaseModel):
     """
     Geospatial draft schema
     """
-    __metadata_type__ = "geospatial"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "geospatial"
+    _metadata_type_version__ = "0.1.0" 
 
     idno: Optional[str] = Field(
         None, description="Project unique identifier", title="Project unique identifier"

pydantic_schemas/image_schema.py

@@ -1170,8 +1170,8 @@ class ImageDataTypeSchema(SchemaBaseModel):
     """
     Uses IPTC JSON schema. See for more details - http://www.iptc.org/std/photometadata/specification/IPTC-PhotoMetadata.
     """
-    __metadata_type__ = "image"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "image"
+    _metadata_type_version__ = "0.1.0" 
 
     repositoryid: Optional[str] = Field(
         "central",

pydantic_schemas/indicator_schema.py

@@ -791,8 +791,8 @@ class TimeseriesSchema(SchemaBaseModel):
     """
     Schema for timeseries data type
     """
-    __metadata_type__ = "indicator"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "indicator"
+    _metadata_type_version__ = "0.1.0" 
 
     idno: Optional[str] = Field(
         None, description="Project unique identifier", title="Project unique identifier"

pydantic_schemas/indicators_db_schema.py

@@ -432,8 +432,8 @@ class TimeseriesDatabaseSchema(SchemaBaseModel):
     """
     Schema for timeseries database
     """
-    __metadata_type__ = "indicators_db"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "indicators_db"
+    _metadata_type_version__ = "0.1.0" 
 
     published: Optional[int] = Field(
         0, description="0=draft, 1=published", title="Status"

pydantic_schemas/metadata_manager.py

@@ -194,10 +194,13 @@ def _get_name_schema_writer(self, metadata_name_or_class):
                 metadata_name = self.standardize_metadata_name(metadata_name_or_class)
                 schema = self._TYPE_TO_SCHEMA[metadata_name]
             else:
-                # for metadata_name, schema in self._TYPE_TO_SCHEMA.items():
-                #     if schema is metadata_name_or_class or schema is type(metadata_name_or_class):
-                #         break
-                metadata_name = self.standardize_metadata_name(metadata_name_or_class.__metadata_type__)
+                metadata_type_from_class = (
+                    metadata_name_or_class._metadata_type__
+                    if isinstance(metadata_name_or_class._metadata_type__, str)
+                    else metadata_name_or_class._metadata_type__.default
+                )
+
+                metadata_name = self.standardize_metadata_name(metadata_type_from_class)
                 schema = metadata_name_or_class
             writer = self._TYPE_TO_WRITER[metadata_name]
         else:
@@ -368,37 +371,54 @@ def read_metadata_from_excel(
         template_uid = metadata_type_info.get("template_uid", None)
 
         if metadata_class is not None:
-            if metadata_class.__metadata_type__ != metadata_name:
+            metadata_type_from_class = (
+                metadata_class._metadata_type__
+                if isinstance(metadata_class._metadata_type__, str)
+                else metadata_class._metadata_type__.default
+            )
+            metadata_type_version_from_class = (
+                metadata_class._metadata_type_version__
+                if isinstance(metadata_class._metadata_type_version__, str)
+                else metadata_class._metadata_type_version__.default
+            )
+            uid_from_class = (
+                metadata_class._template_uid__
+                if isinstance(metadata_class._template_uid__, str)
+                else metadata_class._template_uid__.default
+                if hasattr(metadata_class._template_uid__, "default")
+                else None
+            )
+            if metadata_type_from_class != metadata_name:
                 warnings.warn(
-                    f"metadata_class metadata type {metadata_class.__metadata_type__} does not match the Excel file metadata type {metadata_name}"
+                    f"metadata_class metadata type {metadata_type_from_class} does not match the Excel file metadata type {metadata_name}"
                     "this may cause compatability issues",
                     stacklevel=1,
                 )
-            elif metadata_class.__metadata_type_version__ != metadata_version:
+            elif metadata_type_version_from_class != metadata_version:
                 warnings.warn(
-                    f"metadata_class metadata version {metadata_class.__metadata_type_version__} does not match the Excel file metadata version {metadata_version}"
+                    f"metadata_class metadata version {metadata_type_version_from_class} does not match the Excel file metadata version {metadata_version}"
                     "this may cause issues",
                     stacklevel=1,
                 )
-            elif metadata_class.__template_uid__ is not None and template_uid is None:
+            elif uid_from_class is not None and template_uid is None:
                 warnings.warn(
-                    f"metadata_class template_uid {metadata_class.__template_uid__} does not match the Excel file which is not from a template"
+                    f"metadata_class template_uid {uid_from_class} does not match the Excel file which is not from a template"
                     "this may cause compatability issues",
                     stacklevel=1,
                 )
-            elif metadata_class.__template_uid__ is not None and metadata_class.__template_uid__ != template_uid:
+            elif uid_from_class is not None and uid_from_class != template_uid:
                 warnings.warn(
-                    f"metadata_class template_uid {metadata_class.__template_uid__} does not match the Excel file template_uid {metadata_type_info.get('template_uid', None)}"
+                    f"metadata_class template_uid {uid_from_class} does not match the Excel file template_uid {metadata_type_info.get('template_uid', None)}"
                     "this may cause compatability issues",
                     stacklevel=1,
                 )
-            elif metadata_class.__template_uid__ is None and template_uid is not None:
+            elif uid_from_class is None and template_uid is not None:
                 warnings.warn(
                     "metadata_class is not a template type but the Excel file is from a template"
                     "this may cause compatability issues",
                     stacklevel=1,
                 )
-            metadata_name = metadata_class.__metadata_type__
+            metadata_name = metadata_type_from_class
         else:
             if metadata_type_info.get("template_uid", None) is not None:
                 raise ValueError(
@@ -407,12 +427,17 @@ def read_metadata_from_excel(
             metadata_class = self.metadata_class_from_name(metadata_name)
 
         try:
-            metadata_name = self.standardize_metadata_name(metadata_class.__metadata_type__)
+            metadata_type_from_class = (
+                metadata_class._metadata_type__
+                if isinstance(metadata_class._metadata_type__, str)
+                else metadata_class._metadata_type__.default
+            )
+            metadata_name = self.standardize_metadata_name(metadata_type_from_class)
             reader = self._TYPE_TO_READER[metadata_name]
         except ValueError:
             reader = excel_single_sheet_to_pydantic
             warnings.warn(
-                f"metadata_class metadata type {metadata_class.__metadata_type__} is not a standard type"
+                f"metadata_class metadata type {metadata_type_from_class} is not a standard type"
                 "falling back to excel_single_sheet_to_pydantic",
                 stacklevel=1,
             )

pydantic_schemas/microdata_schema.py

@@ -1222,8 +1222,8 @@ class DdiSchema(SchemaBaseModel):
     """
     Schema for Microdata data type based on DDI 2.5
     """
-    __metadata_type__ = "microdata"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "microdata"
+    _metadata_type_version__ = "0.1.0" 
 
     doc_desc: Optional[DocDesc] = None
     study_desc: Optional[StudyDesc] = None

pydantic_schemas/resource_schema.py

@@ -14,8 +14,8 @@ class Model(SchemaBaseModel):
     """
     External resource schema
     """
-    __metadata_type__ = "resource"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "resource"
+    _metadata_type_version__ = "0.1.0" 
 
     dctype: Optional[str] = Field(
         "doc/oth",

pydantic_schemas/script_schema.py

@@ -682,8 +682,8 @@ class ResearchProjectSchemaDraft(SchemaBaseModel):
     """
     Schema for documenting research projects and data analysis scripts
     """
-    __metadata_type__ = "script"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "script"
+    _metadata_type_version__ = "0.1.0" 
 
     repositoryid: Optional[str] = Field(
         None,

pydantic_schemas/table_schema.py

@@ -525,8 +525,8 @@ class Model(SchemaBaseModel):
     """
     Draft Schema for Table data type
     """
-    __metadata_type__ = "table"
-    __metadata_type_version__ = "0.1.0" 
+    _metadata_type__ = "table"
+    _metadata_type_version__ = "0.1.0" 
 
     repositoryid: Optional[str] = Field(
         None,

pydantic_schemas/tests/test_generators.py

@@ -47,25 +47,32 @@ def test_every_schema_has_version():
     mm = MetadataManager()
     for v in mm.metadata_type_names:
         m = mm.create_metadata_outline(mm.metadata_class_from_name(v))
-        assert m.__metadata_type__ is not None, f"__metadata_type__ is None for {v}"
-        assert m.__metadata_type_version__ is not None, f"__metadata_type_version__ is None for {v}"
-        assert hasattr(m, "__template_name__"), f"__template_name__ not in {v}"
-        assert hasattr(m, "__template_uid__"), f"__template_uid__ not in {v}"
-        assert m.__template_name__ is None, f"__template_name__ is not None for {v} = {m.__template_name__}"
-        assert m.__template_uid__ is None, f"__template_uid__ is not None for {v} = {m.__template_uid__}"
+        assert isinstance(m._metadata_type__, str), f"_metadata_type__ is not a string for {v}"
+        assert m._metadata_type__ is not None, f"_metadata_type__.default is None for {v}"
+        assert isinstance(m._metadata_type_version__, str), f"_metadata_type_version__ is not a string for {v}"
+        assert m._metadata_type_version__ is not None, f"_metadata_type_version__ is None for {v}"
+        assert hasattr(m, "_template_name__"), f"_template_name__ not in {v}"
+        assert hasattr(m, "_template_uid__"), f"_template_uid__ not in {v}"
+        assert m._template_name__ is None, f"_template_name__ is not None for {v} = {m._template_name__}"
+        assert m._template_uid__ is None, f"_template_uid__ is not None for {v} = {m._template_uid__}"
 
         m = mm.create_metadata_outline(v)
-        assert m.__metadata_type__ is not None, f"__metadata_type__ is None for {v}"
-        assert m.__metadata_type_version__ is not None, f"__metadata_type_version__ is None for {v}"
-        assert hasattr(m, "__template_name__"), f"__template_name__ not in {v}"
-        assert hasattr(m, "__template_uid__"), f"__template_uid__ not in {v}"
-        assert m.__template_name__ is None, f"__template_name__ is not None for {v} = {m.__template_name__}"
-        assert m.__template_uid__ is None, f"__template_uid__ is not None for {v} = {m.__template_uid__}"
+        assert isinstance(m._metadata_type__, str), f"_metadata_type__ is not a string for {v}"
+        assert m._metadata_type__ is not None, f"_metadata_type__ is None for {v}"
+        assert isinstance(m._metadata_type_version__, str), f"_metadata_type_version__ is not a string for {v}"
+        assert m._metadata_type_version__ is not None, f"_metadata_type_version__ is None for {v}"
+        assert hasattr(m, "_template_name__"), f"_template_name__ not in {v}"
+        assert hasattr(m, "_template_uid__"), f"_template_uid__ not in {v}"
+        assert m._template_name__ is None, f"_template_name__ is not None for {v} = {m._template_name__}"
+        assert m._template_uid__ is None, f"_template_uid__ is not None for {v} = {m._template_uid__}"
 
         m = mm._TYPE_TO_SCHEMA[v]
-        assert m.__metadata_type__ is not None, f"__metadata_type__ is None for {v}"
-        assert m.__metadata_type_version__ is not None, f"__metadata_type_version__ is None for {v}"
-        assert hasattr(m, "__template_name__"), f"__template_name__ not in {v}"
-        assert hasattr(m, "__template_uid__"), f"__template_uid__ not in {v}"
-        assert m.__template_name__ is None, f"__template_name__ is not None for {v} = {m.__template_name__}"
-        assert m.__template_uid__ is None, f"__template_uid__ is not None for {v} = {m.__template_uid__}"
+        # assert isinstance(m._metadata_type__, str), f"_metadata_type__ is not a string for {v}, it is {type(m._metadata_type__)}({m._metadata_type__})"
+        assert m._metadata_type__.default is not None, f"_metadata_type__.default is None for {v}"
+        assert m._metadata_type_version__.default is not None, f"_metadata_type_version__.default is None for {v}"
+        assert hasattr(m, "_template_name__"), f"_template_name__ not in {v}"
+        assert hasattr(m, "_template_uid__"), f"_template_uid__ not in {v}"
+        assert (
+            m._template_name__.default is None
+        ), f"_template_name__ is not None for {v} = {m._template_name__.default}"
+        assert m._template_uid__.default is None, f"_template_uid__ is not None for {v} = {m._template_uid__.default}"

pydantic_schemas/tests/test_metadata_manager.py

@@ -123,8 +123,8 @@ class Midlevel(BaseModel):
     class TopLevel(SchemaBaseModel):
         e: Optional[Midlevel]
         f: Optional[int]
-        __metadata_type__ = "TopLevel"
-        __metadata_type_version__ = "1.0.0"
+        _metadata_type__ = "TopLevel"
+        _metadata_type_version__ = "1.0.0"
 
     mm = MetadataManager()
     filename1 = tmpdir.join("test_templates_1.xlsx")
@@ -145,8 +145,8 @@ class TopLevel(SchemaBaseModel):
             ],
         ),
         f=99,
-        __metadata_type__="TopLevel",
-        __metadata_type_version__="1.0.0",
+        _metadata_type__="TopLevel",
+        _metadata_type_version__="1.0.0",
     )
 
     filename2 = tmpdir.join("test_templates_2.xlsx")