Changeset 40919 for branches/ipp-259_genericise_backups/tools/backups/utils/config_parse_helper.py

Timestamp:

Oct 8, 2019, 11:42:36 AM (7 years ago)

Author:

fairlamb

Message:

Finished schema parsing tests

File:

• branches/ipp-259_genericise_backups/tools/backups/utils/config_parse_helper.py (modified) (6 diffs)

branches/ipp-259_genericise_backups/tools/backups/utils/config_parse_helper.py

@@ -3 +3 @@
 from backups.utils.errors import ConfigError, ValidationError
 
-# The as configs should be parsed should be pretty uniform. There's a limited
-# amount that can be done with the actual loading.
-
-# Each backup file should be expecting particular lines from a config. So, this
-# means a schema can be made for what each backup expects.
-
 
 class SpecialSchemaProcessing(Enum):
-    """These enums define how a config line should be processed if it is a list
+    """These enums define how processing should be applied to a string to
+separate it out into list.
     """
     commma_separated = 1
@@ -18 +13 @@
 
 class ConfigSchemaLine():
-    """Details the name of key, whether the option is required,
-    and type expected"""
+    """Defines a config line by what the key is, if it is required or optional, 
+the type that the value should be processed as, and any special processing required
+"""
 
     def __init__(self, key: str, required: bool, expected_type, special_processing: SpecialSchemaProcessing=None):
@@ -30 +26 @@
         self.special_processing = special_processing
 
+    def __str__(self):
+        return (f'<{self.__class__.__name__} - '
+                f'Key:{self.key}, '
+                f'Required:{self.required}, '
+                f'Type:{self.expected_type}, '
+                f'Processing: {self.special_processing}'
+                f'>')
+
 
 class ConfigSchema():
-    """Defines the schema to be used"""
+    """Defines a schema to be used. Consists of a single section name and 
+multiple config lines"""
 
     def __init__(self, section_name, options: [ConfigSchemaLine]):
@@ -52 +57 @@
         self.options[line.key] = line
 
+    def key_in_options(self, key: str) -> bool:
+        return key in self.options.keys()
+
+    def get_schema_line(self, key: str) -> ConfigSchemaLine:
+        if not self.key_in_options(key):
+            raise KeyError(f"KeyError: '{key}' is not present in schema")
+        return self.options[key]
+
+    def __str__(self):
+        options_strs = [ o.__str__() for o in self.options]
+        return (f'{self.__class__.__name__} with {options_strs}')
+
 
 def _split_string_to_list(items: str, separator=',') -> [str]:
@@ -60 +77 @@
 
 def parse_config(config: ConfigParser(), schema: ConfigSchema) -> dict:
-    # attempt to parse everything as intended.
+    """For a given config it will extract all values defined by the schema
+and return them as a dictionary of the keys and the assoicated value as the
+type defined by the schema
+"""
     parsed_items = {}
 
     section = schema.section_name
-    for csl in schema.options:
+    for csl_key in schema.options:
+        csl = schema.get_schema_line(csl_key)
+        print(csl)
 
-        if config.has_option(section, csl.key):
-
+        if config.has_option(section, csl_key):
             if csl.expected_type is bool:
                 parsed_items[csl.key] = config.getboolean(section, csl.key)
-            elif csl.expected is int:
+            elif csl.expected_type is int:
                 parsed_items[csl.key] = config.getint(section, csl.key)
             elif csl.expected_type is float:
@@ -79 +100 @@
                 if csl.special_processing == SpecialSchemaProcessing.commma_separated:
                     items = config[section][csl.key]
-                    parsed_items[csl.key] = _split_string_to_list(items, ' ')
-                    # parse comma_separated stuff
+                    splitup = _split_string_to_list(items, ',')
+                    parsed_items[csl.key] = splitup
                 elif csl.special_processing == SpecialSchemaProcessing.space_separated:
                     items = config[section][csl.key]
-                    parsed_items[csl.key] = _split_string_to_list(items, ',')
-                    # space separated processing
+                    splitup = _split_string_to_list(items, ' ')
+                    parsed_items[csl.key] = splitup
                 else:
-                    raise ConfigError(f"ConfigError: Don't know how to process special schema {csl.special_processing}")
+                    raise ConfigError(config, f"ConfigError: Don't know how to process special schema {csl.special_processing}")
             else:
-                raise ConfigError(f"ConfigError: Type '{csl.expected_type}' cannot be processed - need to modify {__name__}")
+                raise ConfigError(config, f"ConfigError: Type '{csl.expected_type}' cannot be processed - need to modify {__name__}")
 
         else:
             if csl.required:
-                raise ConfigError(f"ConfigError: Key '{csl.key}' is required but was not found in config")
+                raise ConfigError(config, f"ConfigError: Key '{csl.key}' is required but was not found in config")
 
     return parsed_items