leaf-common 1.4.3__tar.gz → 1.4.4__tar.gz

{leaf_common-1.4.3 → leaf_common-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leaf-common
-Version: 1.4.3
+Version: 1.4.4
 Summary: LEAF team common code library
 Author-email: Dan Fink <Daniel.Fink@cognizant.com>
 License-Expression: Apache-2.0

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common/config/config_filter.py

@@ -18,6 +18,7 @@
 See class comment for details
 """
 
+from typing import Any
 from typing import Dict
 
 
@@ -32,8 +33,7 @@ class ConfigFilter():
     thus allowing config modification at an early stage in an app's lifecyle.
     """
 
-    def filter_config(self, basis_config: Dict[str, object]) \
-            -> Dict[str, object]:
+    def filter_config(self, basis_config: Dict[str, Any]) -> Dict[str, Any]:
         """
         Filters the given basis config.
 

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common/config/config_filter_chain.py

@@ -17,6 +17,7 @@
 """
 See class comment for details.
 """
+from typing import Any
 from typing import Dict
 from typing import List
 
@@ -48,8 +49,7 @@ class ConfigFilterChain(ConfigFilter):
         """
         self._filters.append(one_filter)
 
-    def filter_config(self, basis_config: Dict[str, object]) \
-            -> Dict[str, object]:
+    def filter_config(self, basis_config: Dict[str, Any]) -> Dict[str, Any]:
         """
         Filters the given basis config.
 
@@ -62,9 +62,10 @@ class ConfigFilterChain(ConfigFilter):
         :return: A config dictionary, potentially modified as per the
                 policy encapsulated by the implementation
         """
-        filtered = basis_config
+        filtered: Dict[str, Any] = basis_config
 
         # Go through the filter chain
+        one_filter: ConfigFilter = None
         for one_filter in self._filters:
             filtered = one_filter.filter_config(filtered)
 

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common/config/config_handler.py

@@ -14,11 +14,9 @@
 # limitations under the License.
 #
 # END COPYRIGHT
-"""
-See class comment for details.
-"""
 from typing import Any
 from typing import Dict
+from typing import Union
 
 from copy import deepcopy
 from collections.abc import Mapping
@@ -33,8 +31,9 @@ class ConfigHandler():
     An abstract class which handles configuration dictionaries
     """
 
-    def import_config(self, config_source, default_config=None,
-                      must_exist=True):
+    def import_config(self, config_source: Union[str, Dict[str, Any]],
+                      default_config: Dict[str, Any] = None,
+                      must_exist: bool = True) -> Dict[str, Any]:
         """
         Main entry point for reading config files
         :param config_source: Either a string filename reference to a
@@ -54,12 +53,12 @@ class ConfigHandler():
         """
 
         # Set up a very basic config dictionary
-        config = {}
+        config: Dict[str, Any] = {}
         if default_config is not None and isinstance(default_config, dict):
             config = deepcopy(default_config)
 
         # Potentially read config from a file, if config arg is a string filename
-        update_source = {}
+        update_source: Dict[str, Any] = {}
         if isinstance(config_source, str):
             update_source = self.read_config_from_file(config_source, must_exist)
 
@@ -68,23 +67,25 @@ class ConfigHandler():
         elif isinstance(config_source, dict):
             update_source = config_source
 
-        new_config = self.deep_update(config, update_source)
+        new_config: Dict[str, Any] = self.deep_update(config, update_source)
         return new_config
 
-    def deep_update(self, dest, source):
+    def deep_update(self, dest: Dict[str, Any], source: Dict[str, Any]) -> Dict[str, Any]:
         """
         Performs overlay functionality
         DEF: Use DictionaryOverlay class instead.
         """
+        key: str = None
+        value: Any = None
         for key, value in source.items():
             if isinstance(value, Mapping):
-                recurse = self.deep_update(dest.get(key, {}), value)
+                recurse: Dict[str, Any] = self.deep_update(dest.get(key, {}), value)
                 dest[key] = recurse
             else:
                 dest[key] = source[key]
         return dest
 
-    def read_config_from_file(self, filepath, must_exist) -> Dict[str, Any]:
+    def read_config_from_file(self, filepath: str, must_exist: bool) -> Dict[str, Any]:
         """
         :param filepath: The file to parse
         :param must_exist: When True, an error is
@@ -96,23 +97,24 @@ class ConfigHandler():
         """
 
         # Create a map of our parser methods
-        file_extension_to_parser_map = {
-            '.conf': 'parse_hocon',
-            '.hocon': 'parse_hocon',
+        file_extension_to_parser_map: Dict[str, str] = {
+            ".conf": "parse_hocon",
+            ".hocon": "parse_hocon",
             # Treat json separately as it's been shown that large json files
             # are really slow for the hocon parser to load.
-            '.json': 'parse_json',
-            '.properties': 'parse_hocon',
-            '.yaml': 'parse_yaml'
+            ".json": "parse_json",
+            ".properties": "parse_hocon",
+            ".yaml": "parse_yaml"
         }
 
         # See what the filepath extension says to use
-        parser = None
+        parser: str = None
+        file_extension: str = None
         for file_extension in list(file_extension_to_parser_map.keys()):
             if filepath.endswith(file_extension):
                 parser = file_extension_to_parser_map.get(file_extension)
 
-        message = f"Could not read {filepath} as config. Unknown file extension."
+        message: str = f"Could not read {filepath} as config. Unknown file extension."
 
         config: Dict[str, Any] = {}
         if parser is not None:
@@ -127,7 +129,7 @@ class ConfigHandler():
 
         return config
 
-    def parse_with_method(self, parser, filepath, must_exist):
+    def parse_with_method(self, parser: str, filepath: str, must_exist: bool) -> Dict[str, Any]:
         """
         :param parser: The parser method on this class to use
         :param filepath: The file to parse
@@ -137,14 +139,17 @@ class ConfigHandler():
                 ignored and a dictionary value of None is returned
         :return: The dictionary parsed from the config file
         """
-        # Python magic to get a handle to the method
-        parser_method = getattr(self, parser)
-
-        # Call the parser method with the filepath, get dictionary back
-        config = parser_method(filepath, must_exist)
+        config: Dict[str, Any] = None
+
+        if parser == "parse_hocon":
+            config = self.parse_hocon(filepath, must_exist)
+        elif parser == "parse_json":
+            config = self.parse_json(filepath, must_exist)
+        elif parser == "parse_yaml":
+            config = self.parse_yaml(filepath, must_exist)
         return config
 
-    def parse_json(self, filepath, must_exist):
+    def parse_json(self, filepath: str, must_exist: bool) -> Dict[str, Any]:
         """
         :param filepath: The json file to parse
         :param must_exist: When True, an error is
@@ -153,12 +158,11 @@ class ConfigHandler():
                 ignored and a dictionary value of None is returned
         :return: The dictionary parsed from the hocon config file
         """
-        persistence = EasyJsonPersistence(full_ref=filepath,
-                                          must_exist=must_exist)
-        config = persistence.restore()
+        persistence = EasyJsonPersistence(full_ref=filepath, must_exist=must_exist)
+        config: Dict[str, Any] = persistence.restore(None)
         return config
 
-    def parse_hocon(self, filepath, must_exist):
+    def parse_hocon(self, filepath: str, must_exist: bool) -> Dict[str, Any]:
         """
         :param filepath: The hocon file to parse
         :param must_exist: When True, an error is
@@ -167,12 +171,11 @@ class ConfigHandler():
                 ignored and a dictionary value of None is returned
         :return: The dictionary parsed from the hocon config file
         """
-        persistence = EasyHoconPersistence(full_ref=filepath,
-                                           must_exist=must_exist)
-        config = persistence.restore()
+        persistence = EasyHoconPersistence(full_ref=filepath, must_exist=must_exist)
+        config: Dict[str, Any] = persistence.restore(None)
         return config
 
-    def parse_yaml(self, filepath, must_exist):
+    def parse_yaml(self, filepath: str, must_exist: bool) -> Dict[str, Any]:
         """
         :param filepath: The yaml file to parse
         :param must_exist: When True, an error is
@@ -181,7 +184,6 @@ class ConfigHandler():
                 ignored and a dictionary value of None is returned
         :return: The dictionary parsed from the yaml config file
         """
-        persistence = EasyYamlPersistence(full_ref=filepath,
-                                          must_exist=must_exist)
-        config = persistence.restore()
+        persistence = EasyYamlPersistence(full_ref=filepath, must_exist=must_exist)
+        config: Dict[str, Any] = persistence.restore(None)
         return config

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common/config/config_util.py

@@ -56,16 +56,21 @@ class ConfigUtil:
         """
         if key not in config:
             return default
+
         value: Any = config[key]
         if isinstance(value, bool):
             return value
+
         if isinstance(value, str):
-            lowered = value.strip().lower()
+            string_value: str = value
+            lowered: str = string_value.strip().lower()
             if lowered in ("true", "yes"):
                 return True
             if lowered in ("false", "no"):
                 return False
             return default
+
         if isinstance(value, int):
             return value != 0
+
         return default

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common/config/dictionary_overlay.py

@@ -14,9 +14,10 @@
 # limitations under the License.
 #
 # END COPYRIGHT
-"""
-See class comment for details.
-"""
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Set
 
 
 class DictionaryOverlay():
@@ -24,7 +25,8 @@ class DictionaryOverlay():
     Policy class assisting with deep dictionary updates.
     """
 
-    def overlay(self, basis, overlay, allow_overlay_only_items=True):
+    def overlay(self, basis: Dict[str, Any], overlay: Dict[str, Any],
+                allow_overlay_only_items: bool = True) -> Dict[str, Any]:
         """
         :param basis: The basis dictionary to be overlayed.
                         Unmodified on exit.
@@ -42,20 +44,21 @@ class DictionaryOverlay():
                 are both dictionaries, this method recurses.
         """
 
-        overlay_only_items = set()
-        result = self._do_overlay(basis, overlay, overlay_only_items, '')
+        overlay_only_items: Set[str] = set()
+        result: Dict[str, Any] = self._do_overlay(basis, overlay, overlay_only_items, '')
         # Now, let's check if we had items present in "overlay"
         # but not in "basis" dictionary.
         # If YES - always print out warning message;
         # and if we don't allow overlay-only items, raise an exception.
-        if len(overlay_only_items) > 0 \
-                and not allow_overlay_only_items:
-            separator = ', '
-            message = separator.join(overlay_only_items)
+        if len(overlay_only_items) > 0 and not allow_overlay_only_items:
+            separator: str = ", "
+            overlay_only_list: List[str] = sorted(list(overlay_only_items))
+            message: str = separator.join(overlay_only_list)
             raise ValueError(f"overlay items not present in basis: {message}")
         return result
 
-    def _do_overlay(self, basis, overlay, overlay_only_items, items_prefix):
+    def _do_overlay(self, basis: Dict[str, Any], overlay: Dict[str, Any],
+                    overlay_only_items: Set[str], items_prefix: str) -> Dict[str, Any]:
         """
         :param basis: The basis dictionary to be overlayed.
                         Unmodified on exit.
@@ -77,46 +80,49 @@ class DictionaryOverlay():
         if basis is None and overlay is None:
             return None
 
+        use_basis: Dict[str, Any] = basis
         if basis is None:
-            basis = {}
+            use_basis = {}
 
-        if not isinstance(basis, dict):
+        if not isinstance(use_basis, dict):
             raise ValueError("basis is not a dictionary")
 
+        use_overlay: Dict[str, Any] = overlay
         if overlay is None:
-            overlay = {}
+            use_overlay = {}
 
-        if not isinstance(overlay, dict):
+        if not isinstance(use_overlay, dict):
             raise ValueError("overlay is not a dictionary")
 
         # Do not modify any incoming arguments
-        result = {}
-        result.update(basis)
+        result: Dict[str, Any] = {}
+        result.update(use_basis)
 
-        for key in overlay.keys():
+        key: str = None
+        for key in use_overlay.keys():
 
             # Any key we do not have, we just copy over the value from overlay.
-            if key not in basis:
-                result[key] = overlay[key]
-                overlay_only_items.add(items_prefix+key)
+            if key not in use_basis.keys():
+                result[key] = use_overlay[key]
+                add_key: str = items_prefix + key
+                overlay_only_items.add(add_key)
                 continue
 
-            basis_value = basis.get(key)
-            overlay_value = overlay.get(key)
+            basis_value: Any = use_basis.get(key)
+            overlay_value: Any = use_overlay.get(key)
 
-            if basis_value is not None \
-                    and overlay_value is not None:
+            if basis_value is not None and overlay_value is not None:
                 # Adjust overlay value type here:
                 # if "basis" contains say A = 3 and overlay contains A = '3',
                 # we try to convert overlay string to numeric type
                 # by parsing it. This takes care of situation
                 # when overlay value comes from environment variable,
                 # which is always a string.
-                overlay_value = self._convert_overlay_value(basis_value, overlay_value)
+                overlay_value: Any = self._convert_overlay_value(basis_value, overlay_value)
 
             # By default, the result value for the key will be the overlay
             # value itself.
-            result_value = overlay_value
+            result_value: Any = overlay_value
 
             # ... except if both values are dictionaries.
             # In that case, recurse.
@@ -131,7 +137,7 @@ class DictionaryOverlay():
 
         return result
 
-    def _convert_overlay_value(self, basis_value, overlay_value):
+    def _convert_overlay_value(self, basis_value: Any, overlay_value: Any) -> Any:
         """
         Given basis value from configuration and overlay value
         we need to replace it with, convert overlay value if necessary.
@@ -145,12 +151,13 @@ class DictionaryOverlay():
                  in configuration.
         """
 
+        use_value: Any = overlay_value
         if isinstance(overlay_value, str):
+            string_value: str = overlay_value
             if isinstance(basis_value, bool):
-                overlay_value = \
-                    bool(overlay_value.strip().lower() == 'true')
+                use_value = bool(string_value.strip().lower() == 'true')
             elif isinstance(basis_value, int):
-                overlay_value = int(float(overlay_value))
+                use_value = int(float(string_value))
             elif isinstance(basis_value, float):
-                overlay_value = float(overlay_value)
-        return overlay_value
+                use_value = float(string_value)
+        return use_value

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common/config/file_of_class.py

@@ -14,12 +14,9 @@
 # limitations under the License.
 #
 # END COPYRIGHT
-"""
-See class comment for details.
-"""
 
 from pathlib import Path
-import os
+from os.path import expanduser
 
 
 class FileOfClass:
@@ -105,7 +102,7 @@ class FileOfClass:
 
         if basis == "~":
             # Special case if we are looking under user's home directory
-            basis = os.path.expanduser("~")
+            basis = expanduser("~")
         basis_abs_path: str = str(Path(basis).resolve())
 
         if not test_abs_path.startswith(basis_abs_path):

leaf_common-1.4.4/leaf_common/filters/composite_string_filter.py

@@ -0,0 +1,59 @@
+
+# Copyright © 2019-2026 Cognizant Technology Solutions Corp, www.cognizant.com.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# END COPYRIGHT
+from typing import List
+
+from leaf_common.filters.string_filter import StringFilter
+
+
+class CompositeStringFilter(StringFilter):
+    """
+    An implementation of the StringFilter interface which puts together
+    multiple string filter operations in a certain order
+    """
+
+    def __init__(self, filters: List[StringFilter] = None):
+        """
+        Constructor
+
+        :param filters: A list of StringFilter class instances to apply in order
+        """
+
+        self._filters: List[StringFilter] = []
+
+        if filters is not None:
+            one_filter: StringFilter = None
+            for one_filter in filters:
+                self.add_filter(one_filter)
+
+    def add_filter(self, new_filter: StringFilter):
+        """
+        :param new_filter: The StringFilter to be added to the list to be applied
+        """
+        self._filters.append(new_filter)
+
+    def filter(self, in_string: str) -> str:
+        """
+        :param in_string: an input string to filter
+        :return: a filtered version of the in_string, according to implementation policy
+        """
+        accumulator: str = in_string
+
+        string_filter: StringFilter = None
+        for string_filter in self._filters:
+            accumulator = string_filter.filter(accumulator)
+
+        return accumulator

leaf_common-1.4.4/leaf_common/filters/string_filter.py

@@ -0,0 +1,35 @@
+
+# Copyright © 2019-2026 Cognizant Technology Solutions Corp, www.cognizant.com.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# END COPYRIGHT
+
+
+# pylint: disable=too-few-public-methods
+class StringFilter:
+    """
+    Interface whose filter() method takes one string and returns another string
+    which is a filtered version of the input.
+
+    These kinds of things are necessary for the following reasons:
+    * Tensorflow only likes column names with certain characters in them
+    * HTML UI sometimes only likes certain characters in strings.
+    """
+
+    def filter(self, in_string: str) -> str:
+        """
+        :param in_string: an input string to filter
+        :return: a filtered version of the in_string, according to implementation policy
+        """
+        raise NotImplementedError

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common/parsers/dictionary_extractor.py

@@ -29,8 +29,7 @@ class DictionaryExtractor():
     Policy class that pairs a specific dictionary instance with a FieldExtractor.
     """
 
-    def __init__(self, dictionary: Dict[str, Any],
-                 delimiter: str = "."):
+    def __init__(self, dictionary: Dict[str, Any], delimiter: str = "."):
         """
         Constructor
 
@@ -41,7 +40,7 @@ class DictionaryExtractor():
         self.delimiter: str = delimiter
         self.extractor = FieldExtractor()
 
-    def get(self, field_name, default_value=None):
+    def get(self, field_name: str, default_value: Any = None) -> Any:
         """
         :param field_name: the fully specified field name.
         :param default_value: a default value if the field is not found.

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common/parsers/field_extractor.py

@@ -14,9 +14,9 @@
 # limitations under the License.
 #
 # END COPYRIGHT
-"""
-See class comment for details.
-"""
+from typing import Any
+from typing import Dict
+from typing import List
 
 
 class FieldExtractor():
@@ -26,8 +26,8 @@ class FieldExtractor():
     values imply nested dictionary lookup.
     """
 
-    def get_field(self, dictionary, field_name, default_value=None,
-                  delimiter="."):
+    def get_field(self, dictionary: Dict[str, Any], field_name: str, default_value: Any = None,
+                  delimiter: str = ".") -> Any:
         """
         :param dictionary: the dictionary in which the field
             is supposed exist.
@@ -57,23 +57,21 @@ class FieldExtractor():
             return dictionary.get(field_name, default_value)
 
         # Handle the more complex case of a delimited key
-        field_split = field_name.split(delimiter)
-        use_field_name = field_split[0]
+        field_split: List[str] = field_name.split(delimiter)
+        use_field_name: str = field_split[0]
 
         # Get the value for the segment of the field name
         # If it's not a dictionary, return the default value,
         # as we know we have more to look for.
-        value = dictionary.get(use_field_name, None)
-        if value is None or \
-                not isinstance(value, dict):
+        value: Any = dictionary.get(use_field_name, None)
+        if value is None or not isinstance(value, dict):
             return default_value
 
         # We know the value is a dictionary.
         # Get the remaining bit of the delimited field
         # into its own string for recursion
-        remaining_split = field_split[1:len(field_split)+1]
-        remaining_field = delimiter.join(remaining_split)
+        remaining_split: List[str] = field_split[1:len(field_split)+1]
+        remaining_field: str = delimiter.join(remaining_split)
 
-        deep_value = self.get_field(value, remaining_field,
-                                    default_value, delimiter)
+        deep_value: Any = self.get_field(value, remaining_field, default_value, delimiter)
         return deep_value

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leaf-common
-Version: 1.4.3
+Version: 1.4.4
 Summary: LEAF team common code library
 Author-email: Dan Fink <Daniel.Fink@cognizant.com>
 License-Expression: Apache-2.0

{leaf_common-1.4.3 → leaf_common-1.4.4}/leaf_common.egg-info/SOURCES.txt

@@ -43,6 +43,8 @@ leaf_common/config/config_util.py
 leaf_common/config/dictionary_overlay.py
 leaf_common/config/environment_defaults.py
 leaf_common/config/file_of_class.py
+leaf_common/filters/composite_string_filter.py
+leaf_common/filters/string_filter.py
 leaf_common/logging/__init__.py
 leaf_common/logging/conditional_logger.py
 leaf_common/logging/example_logging_config.hocon