Add Default function for schemas

.pylintrc

@@ -85,7 +85,8 @@ disable=raw-checker-failed,
         bad-inline-option,
         line-too-long,
         unnecessary-pass,
-        import-error
+        import-error,
+        dangerous-default-value
 
 # Enable the message, report, category or checker with the given id(s). You can
 # either give multiple identifier separated by comma (,) or put this option

src/ogd/common/schemas/Schema.py

@@ -1,7 +1,7 @@
 # import standard libraries
 import abc
 import logging
-from typing import Any, Callable, Dict, List, Optional, Self
+from typing import Any, Callable, Dict, List, Optional
 # import local files
 from ogd.common.utils.Logger import Logger
 
@@ -17,6 +17,30 @@ def AsMarkdown(self) -> str:
     @classmethod
     @abc.abstractmethod
     def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging.Logger]=None)-> "Schema":
+        """_summary_
+
+        TODO : Make classmethod, slightly simplifies how we access default values
+
+        :param name: _description_
+        :type name: str
+        :param all_elements: _description_
+        :type all_elements: Dict[str, Any]
+        :param logger: _description_, defaults to None
+        :type logger: Optional[logging.Logger], optional
+        :return: _description_
+        :rtype: Schema
+        """
+        pass
+
+    @classmethod
+    @abc.abstractmethod
+    def Default(cls) -> "Schema":
+        """Property to get an instance of the Schema with default member values.
+
+        Note that these defaults may or may not be a usable configuration.
+        :return: A schema with default member values.
+        :rtype: Self
+        """
         pass
 
     # *** BUILT-INS & PROPERTIES ***
@@ -53,6 +77,23 @@ def NonStandardElementNames(self) -> List[str]:
 
     @classmethod
     def ElementFromDict(cls, all_elements:Dict[str, Any], element_names:List[str], parser_function:Callable, default_value:Any, logger:Optional[logging.Logger]=None) -> Any:
+        """_summary_
+
+        TODO : Redo this concept in a way that we can still get type safety by directly calling parse functions in individual schema classes.
+
+        :param all_elements: _description_
+        :type all_elements: Dict[str, Any]
+        :param element_names: _description_
+        :type element_names: List[str]
+        :param parser_function: _description_
+        :type parser_function: Callable
+        :param default_value: _description_
+        :type default_value: Any
+        :param logger: _description_, defaults to None
+        :type logger: Optional[logging.Logger], optional
+        :return: _description_
+        :rtype: Any
+        """
         for name in element_names:
             if name in all_elements:
                 return parser_function(all_elements[name])

src/ogd/common/schemas/configs/GameSourceSchema.py

@@ -3,11 +3,17 @@
 from typing import Any, Dict, List, Optional, Union
 # import local files
 from ogd.common.schemas.configs.data_sources.DataSourceSchema import DataSourceSchema
+from ogd.common.schemas.configs.data_sources.BigQuerySourceSchema import BigQuerySchema
 from ogd.common.schemas.Schema import Schema
 from ogd.common.utils.Logger import Logger
 
 class GameSourceSchema(Schema):
 
+    _DEFAULT_SOURCE_NAME   = "OPENGAMEDATA_BQ"
+    _DEFAULT_DB_NAME       = "UNKNOWN GAME"
+    _DEFAULT_TABLE_NAME    = "_daily"
+    _DEFAULT_TABLE_SCHEMA  = "OPENGAMEDATA_BIGQUERY"
+
     # *** BUILT-INS & PROPERTIES ***
 
     """A simple Schema structure containing configuration information for a particular game's data.
@@ -66,6 +72,18 @@ def AsMarkdown(self) -> str:
         ret_val = f"{self.Name}: _{self.TableSchema}_ format, source {self.Source.Name if self.Source else 'None'} : {self.DatabaseName}.{self.TableName}"
         return ret_val
 
+    @classmethod
+    def Default(cls) -> "GameSourceSchema":
+        return GameSourceSchema(
+            name="DefaultGameSourceSchema",
+            source_name=cls._DEFAULT_SOURCE_NAME,
+            source_schema=BigQuerySchema.Default(),
+            db_name=cls._DEFAULT_DB_NAME,
+            table_name=cls._DEFAULT_TABLE_NAME,
+            table_schema=cls._DEFAULT_TABLE_SCHEMA,
+            other_elements={}
+        )
+
     @classmethod
     def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging.Logger], data_sources:Dict[str, DataSourceSchema]) -> "GameSourceSchema":
         """Create a GameSourceSchema from a given dictionary
@@ -97,7 +115,7 @@ def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging
         _source_name = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["source"],
             parser_function=cls._parseSource,
-            default_value="UNKNOWN"
+            default_value=GameSourceSchema._DEFAULT_SOURCE_NAME
         )
         if _source_name in data_sources.keys():
             _source_schema = data_sources[_source_name]
@@ -113,12 +131,12 @@ def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging
         _table_name = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["table"],
             parser_function=cls._parseTableName,
-            default_value="UNKNOWN"
+            default_value=GameSourceSchema._DEFAULT_TABLE_NAME
         )
         _table_schema = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["schema"],
             parser_function=cls._parseTableSchemaName,
-            default_value="UNKNOWN"
+            default_value=GameSourceSchema._DEFAULT_TABLE_SCHEMA
         )
 
         _used = {"source", "database", "table", "schema"}

src/ogd/common/schemas/configs/IndexingSchema.py

@@ -7,6 +7,9 @@
 from ogd.common.utils.Logger import Logger
 
 class FileIndexingSchema(Schema):
+    _DEFAULT_LOCAL_DIR  = Path("./data/")
+    _DEFAULT_REMOTE_URL = "https://fieldday-web.ad.education.wisc.edu/opengamedata/"
+    _DEFAULT_TEMPLATE_URL  = "https://github.com/opengamedata/opengamedata-samples"
 
     # *** BUILT-INS & PROPERTIES ***
 
@@ -30,6 +33,16 @@ def TemplatesURL(self) -> str:
 
     # *** IMPLEMENT ABSTRACT FUNCTIONS ***
 
+    @classmethod
+    def Default(cls) -> "FileIndexingSchema":
+        return FileIndexingSchema(
+            name            = "DefaultFileIndexingSchema",
+            local_dir       = cls._DEFAULT_LOCAL_DIR,
+            remote_url      = cls._DEFAULT_REMOTE_URL,
+            templates_url   = cls._DEFAULT_TEMPLATE_URL,
+            other_elements  = {}
+        )
+
     @classmethod
     def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging.Logger]=None)-> "FileIndexingSchema":
         _local_dir     : Path
@@ -46,17 +59,17 @@ def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging
         _local_dir = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["LOCAL_DIR"],
             parser_function=cls._parseLocalDir,
-            default_value=Path("./data/")
+            default_value=FileIndexingSchema._DEFAULT_LOCAL_DIR
         )
         _remote_url = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["REMOTE_URL"],
             parser_function=cls._parseRemoteURL,
-            default_value=None
+            default_value=FileIndexingSchema._DEFAULT_REMOTE_URL
         )
         _templates_url = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["TEMPLATES_URL"],
             parser_function=cls._parseTemplatesURL,
-            default_value="https://github.com/opengamedata/opengamedata-samples"
+            default_value=FileIndexingSchema._DEFAULT_TEMPLATE_URL
         )
 
         _used = {"LOCAL_DIR", "REMOTE_URL", "TEMPLATES_URL"}

src/ogd/common/schemas/configs/TestConfigSchema.py

@@ -19,17 +19,11 @@
 # import local files
 
 class TestConfigSchema(Schema):
+    _DEFAULT_VERBOSE       = False
+    _DEFAULT_ENABLED_TESTS = {}
 
     # *** BUILT-INS & PROPERTIES ***
 
-    @staticmethod
-    def DEFAULT():
-        return TestConfigSchema(
-            name            = "DefaultTestConfig",
-            verbose         = False,
-            enabled_tests   = {}
-        )
-
     def __init__(self, name:str, verbose:bool, enabled_tests:Dict[str, bool], other_elements:Dict[str, Any]={}):
         self._verbose       : bool            = verbose
         self._enabled_tests : Dict[str, bool] = enabled_tests
@@ -51,6 +45,14 @@ def AsMarkdown(self) -> str:
         return ret_val
 
     # *** IMPLEMENT ABSTRACT FUNCTIONS ***
+
+    @classmethod
+    def Default(cls) -> "TestConfigSchema":
+        return TestConfigSchema(
+            name            = "DefaultTestConfig",
+            verbose         = cls._DEFAULT_VERBOSE,
+            enabled_tests   = cls._DEFAULT_ENABLED_TESTS
+        )
 
     # *** PUBLIC STATICS ***
 
@@ -69,12 +71,12 @@ def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging
         _verbose = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["VERBOSE"],
             parser_function=cls._parseVerbose,
-            default_value=cls.DEFAULT().Verbose
+            default_value=cls._DEFAULT_VERBOSE
         )
         _enabled_tests = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["ENABLED"],
             parser_function=cls._parseEnabledTests,
-            default_value=cls.DEFAULT().EnabledTests
+            default_value=cls._DEFAULT_ENABLED_TESTS
         )
 
         _used = {"VERBOSE", "ENABLED"}
@@ -111,7 +113,7 @@ def _parseEnabledTests(enabled, logger:Optional[logging.Logger]=None) -> Dict[st
         if isinstance(enabled, dict):
             ret_val = { str(key) : bool(val) for key, val in enabled.items() }
         else:
-            ret_val = TestConfigSchema.DEFAULT().EnabledTests
+            ret_val = TestConfigSchema.Default().EnabledTests
             _msg = f"Config 'enabled tests' setting was unexpected type {type(enabled)}, defaulting to class default = {ret_val}."
             if logger:
                 logger.warn(_msg, logging.WARN)

src/ogd/common/schemas/configs/data_sources/BigQuerySourceSchema.py

@@ -7,6 +7,8 @@
 from ogd.common.utils.Logger import Logger
 
 class BigQuerySchema(DataSourceSchema):
+    _DEFAULT_PROJECT_ID = "wcer-field-day-ogd-1798"
+    _DEFAULT_CREDENTIAL = "./config/ogd.json"
 
     # *** BUILT-INS & PROPERTIES ***
 
@@ -38,6 +40,15 @@ def AsMarkdown(self) -> str:
         ret_val = f"{self.Name}: `{self.AsConnectionInfo}` ({self.Type})"
         return ret_val
 
+    @classmethod
+    def Default(cls) -> "BigQuerySchema":
+        return BigQuerySchema(
+            name="DefaultBigQuerySchema",
+            project_id=cls._DEFAULT_PROJECT_ID,
+            credential=cls._DEFAULT_CREDENTIAL,
+            other_elements={}
+        )
+
     @classmethod
     def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging.Logger]) -> "BigQuerySchema":
         _project_id : str
@@ -49,12 +60,12 @@ def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging
         _project_id = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["PROJECT_ID", "DATASET_ID"],
             parser_function=cls._parseProjectID,
-            default_value="UNKNOWN"
+            default_value=BigQuerySchema._DEFAULT_PROJECT_ID
         )
         _credential = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["PROJECT_KEY"],
             parser_function=cls._parseCredential,
-            default_value=None
+            default_value=BigQuerySchema._DEFAULT_CREDENTIAL
         )
 
         _used = {"PROJECT_ID", "DATASET_ID", "PROJECT_KEY"}

src/ogd/common/schemas/configs/data_sources/FileSourceSchema.py

@@ -7,6 +7,8 @@
 from ogd.common.utils.Logger import Logger
 
 class FileSourceSchema(DataSourceSchema):
+    _DEFAULT_FOLDER_PATH = Path('./data')
+    _DEFAULT_FILE_NAME = "UNKNOWN.tsv"
 
     # *** BUILT-INS & PROPERTIES ***
 
@@ -49,7 +51,7 @@ def AsConnectionInfo(self) -> str:
     @classmethod
     def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging.Logger]=None)-> "FileSourceSchema":
         _folder_path : Path
-        _file_name   : Optional[str]
+        _file_name   : str
 
         if not isinstance(all_elements, dict):
             all_elements = {}
@@ -61,18 +63,27 @@ def FromDict(cls, name:str, all_elements:Dict[str, Any], logger:Optional[logging
         _folder_path = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["PATH"],
             parser_function=cls._parseFolder,
-            default_value=Path("./data/")
+            default_value=FileSourceSchema._DEFAULT_FOLDER_PATH
         )
         _file_name = cls.ElementFromDict(all_elements=all_elements, logger=logger,
             element_names=["FILENAME"],
             parser_function=cls._parseFilename,
-            default_value="UNKNOWN.tsv"
+            default_value=FileSourceSchema._DEFAULT_FILE_NAME
         )
 
         _used = {"PATH", "FILENAME"}
         _leftovers = { key : val for key,val in all_elements.items() if key not in _used }
         return FileSourceSchema(name=name, folder_path=_folder_path, file_name=_file_name, other_elements=_leftovers)
 
+    @classmethod
+    def Default(cls) -> "FileSourceSchema":
+        return FileSourceSchema(
+            name="DefaultFileSourceSchema",
+            folder_path=cls._DEFAULT_FOLDER_PATH,
+            file_name=cls._DEFAULT_FILE_NAME,
+            other_elements={}
+        )
+
     # *** PUBLIC STATICS ***
 
     # *** PUBLIC METHODS ***