leaf-common 1.2.37__tar.gz → 1.2.38__tar.gz

leaf_common-1.2.38/.github/workflows/tests.yml

@@ -0,0 +1,29 @@
+---
+name: Test
+
+"on":
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    # 455db3c = build-common 1.0.0
+    # https://github.com/cognizant-ai-lab/build-common/releases
+    uses: cognizant-ai-lab/build-common/.github/workflows/_python-quality-gate.yml@455db3cc40e9ed6a0fb9bbaf8188888c1ae315c2
+    with:
+      lint-toolchain: "legacy"
+      python-version: "3.12"
+      pylint-command: "build_scripts/run_pylint.sh"
+      run-shellcheck: true
+      pytest-markers: "not integration"
+      pytest-extra-args: "--timer-top-n 10 --cov-config=.coveragerc --cov"
+      check-readme-pypi: true
+    secrets:
+      SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+
+

{leaf_common-1.2.37/leaf_common.egg-info → leaf_common-1.2.38}/PKG-INFO

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

{leaf_common-1.2.37 → leaf_common-1.2.38}/build_scripts/run_flake8.sh

@@ -2,11 +2,11 @@
 
 # set -euo pipefail
 
-UP_TO_SNUFF_DIRS=`ls -1`
+UP_TO_SNUFF_DIRS=$(ls -1)
 IGNORE="build_scripts"
 
 dirs=$1
-if [ "x${dirs}" == "x" ]
+if [ "${dirs}" == "" ]
 then
     dirs=${UP_TO_SNUFF_DIRS}
 fi
@@ -26,18 +26,18 @@ do
     # See if it's a directory we specifically want to ignore
     for ignore_dir in ${IGNORE}
     do
-        if [ "x${ignore_dir}" == $"x${dir}" ]
+        if [ "${ignore_dir}" == "${dir}" ]
         then
             ignore_this=${dir}
         fi
     done
 
     # If we do not need to ignore...
-    if [ "x" == "x${ignore_this}" ]
+    if [ "" == "${ignore_this}" ]
     then
         echo "Running flake8 on directory '${dir}':"
-        find "${dir}" -iname "*.py" | \
-            xargs flake8 -j 0
+        find "${dir}" -iname "*.py" -print0 | \
+            xargs --null flake8 --jobs 0
         current_retval=$?
         if [ ${current_retval} -ne 0 ]
         then

{leaf_common-1.2.37 → leaf_common-1.2.38}/build_scripts/run_pylint.sh

@@ -8,7 +8,7 @@ DEPENDENCY_DIRS=""
 IGNORE="${DEPENDENCY_DIRS} build_scripts"
 
 dirs=$1
-if [ "x${dirs}" == "x" ]
+if [ "${dirs}" == "" ]
 then
     dirs=${UP_TO_SNUFF_DIRS}
 fi
@@ -30,14 +30,14 @@ do
     # See if it's a directory we specifically want to ignore
     for ignore_dir in ${IGNORE}
     do
-        if [ "x${ignore_dir}" == $"x${dir}" ]
+        if [ "${ignore_dir}" == "${dir}" ]
         then
             ignore_this=${dir}
         fi
     done
 
     # If we do not need to ignore...
-    if [ "x" == "x${ignore_this}" ]
+    if [ "" == "${ignore_this}" ]
     then
         use_dirs="${use_dirs} ${dir}"
     fi

{leaf_common-1.2.37 → leaf_common-1.2.38}/leaf_common/config/resolver.py

@@ -75,16 +75,7 @@ class Resolver():
         if verbose:
             logger.info("Attempting to resolve module %s", use_module_name)
 
-        if self.packages is not None:
-            for package in self.packages:
-                fully_qualified_module: str = f"{package}.{use_module_name}"
-                found_module: Any = self.try_to_import_module(fully_qualified_module,
-                                                              messages, install_if_missing)
-                if found_module is not None:
-                    break
-        else:
-            found_module: Any = self.try_to_import_module(use_module_name, messages,
-                                                          install_if_missing)
+        found_module: Any = self._find_module(use_module_name, messages, install_if_missing)
 
         if found_module is None:
             message: str = f"Could not find code for {use_module_name}"
@@ -108,6 +99,37 @@ class Resolver():
 
         return my_class
 
+    def _find_module(self, use_module_name: str, messages: List[str],
+                     install_if_missing: str = None) -> Any:
+        """
+        Searches for a module by name, trying each configured package in turn.
+        Also tries the module name as a top-level module if packages are configured.
+
+        :param use_module_name: The module name to search for
+        :param messages: a list of messages where logs of failed attempts can go
+        :param install_if_missing: Optional name of a package to install if the module is missing.
+        :return: The python module if found. None if not found.
+        """
+
+        if self.packages is None:
+            return self.try_to_import_module(use_module_name, messages, install_if_missing)
+
+        for package in self.packages:
+            fully_qualified_module: str = f"{package}.{use_module_name}"
+            found_module: Any = self.try_to_import_module(fully_qualified_module,
+                                                          messages, install_if_missing)
+
+            if found_module is not None:
+                return found_module
+
+            # check main package
+            check_main_package: Any = self.try_to_import_module(package,
+                                                                messages, install_if_missing)
+            if check_main_package is not None:
+                return check_main_package
+
+        return None
+
     def try_to_import_module(self, module: str, messages: List[str],
                              install_if_missing: str = None) -> Any:
         """

{leaf_common-1.2.37 → leaf_common-1.2.38}/leaf_common/config/resolver_util.py

@@ -80,20 +80,30 @@ class ResolverUtil:
         if class_name is None or len(class_name) == 0:
             return None
 
+        value_error_message: str = (f"Value from {class_name_source} '{class_name}' "
+                                    "must be of the form <package_name>.<module_name>.<ClassName> "
+                                    "or <package_name>.<ClassName> ")
         # Split the single string into package, module, and class name
         class_split: List[str] = class_name.split(".")
-        if len(class_split) <= 2:
-            raise ValueError(f"Value from {class_name_source} '{class_name}' "
-                             "must be of the form <package_name>.<module_name>.<ClassName>")
+        if len(class_split) < 2:
+            raise ValueError(value_error_message)
 
-        packages: List[str] = [".".join(class_split[:-2])]
+        # Extract module and class details
+        if len(class_split) <= 2:
+            # handles <package_name>.<ClassName>
+            packages: List[str] = [class_split[0]]
+            module_name = class_split[0]
+        else:
+            # handles <package_name>.<module_name>.<ClassName>
+            packages: List[str] = [".".join(class_split[:-2])]
+            module_name = class_split[-2]
         class_name: str = class_split[-1]
         resolver = Resolver(packages)
 
         # Resolve the class name
         class_reference: Type[Any] = None
         try:
-            class_reference = resolver.resolve_class_in_module(class_name, module_name=class_split[-2])
+            class_reference = resolver.resolve_class_in_module(class_name, module_name=module_name)
         except AttributeError as exception:
             raise ValueError(f"Class '{class_name}' from {class_name_source} "
                              "not found in PYTHONPATH") from exception

{leaf_common-1.2.37 → leaf_common-1.2.38/leaf_common.egg-info}/PKG-INFO

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

{leaf_common-1.2.37 → leaf_common-1.2.38}/leaf_common.egg-info/SOURCES.txt

@@ -226,6 +226,7 @@ tests/candidates/__init__.py
 tests/candidates/test_representation_types.py
 tests/config/__init__.py
 tests/config/dictionary_overlay_test.py
+tests/config/resolver_util_test.py
 tests/filters/__init__.py
 tests/filters/test_sanitizer_util.py
 tests/filters/test_tensorflow_field_name_filter.py

leaf_common-1.2.38/tests/config/resolver_util_test.py

@@ -0,0 +1,243 @@
+
+# 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
+"""
+See class comment for details
+"""
+
+from unittest import TestCase
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+
+from leaf_common.config.resolver_util import ResolverUtil
+
+RESOLVER_PATH = "leaf_common.config.resolver.Resolver.resolve_class_in_module"
+
+
+class ResolverUtilTest(TestCase):
+    """
+    Tests for ResolverUtil.
+    """
+
+    # -------------------------------------------------------------------------
+    # create_class tests
+    # -------------------------------------------------------------------------
+
+    def test_create_class_none_returns_none(self):
+        """
+        None class_name should return None without raising.
+        """
+        result = ResolverUtil.create_class(None, "test_source", object)
+        self.assertIsNone(result)
+
+    def test_create_class_empty_string_returns_none(self):
+        """
+        Empty class_name should return None without raising.
+        """
+        result = ResolverUtil.create_class("", "test_source", object)
+        self.assertIsNone(result)
+
+    def test_create_class_too_few_parts_raises(self):
+        """
+        A class_name with no dots (single part) should raise ValueError.
+        """
+        with self.assertRaises(ValueError):
+            ResolverUtil.create_class("ClassName", "test_source", object)
+
+    def test_create_class_two_part_name(self):
+        """
+        <package_name>.<ClassName> form should resolve correctly.
+        """
+        mock_class = MagicMock()
+        mock_class.__mro__ = [mock_class, object]
+
+        with patch(RESOLVER_PATH, return_value=mock_class) as mock_resolve, \
+             patch("builtins.issubclass", return_value=True):
+            result = ResolverUtil.create_class("my_package.MyClass", "test_source", object)
+
+        mock_resolve.assert_called_once_with("MyClass", module_name="my_package")
+        self.assertIs(result, mock_class)
+
+    def test_create_class_three_part_name(self):
+        """
+        <package_name>.<module_name>.<ClassName> form should resolve correctly.
+        """
+        mock_class = MagicMock()
+
+        with patch(RESOLVER_PATH, return_value=mock_class) as mock_resolve, \
+             patch("builtins.issubclass", return_value=True):
+            result = ResolverUtil.create_class(
+                "my_package.my_module.MyClass", "test_source", object
+            )
+
+        mock_resolve.assert_called_once_with("MyClass", module_name="my_module")
+        self.assertIs(result, mock_class)
+
+    def test_create_class_multi_part_package(self):
+        """
+        <pkg>.<sub>.<module>.<ClassName> — everything before the last two parts
+        is treated as the package path.
+        """
+        mock_class = MagicMock()
+
+        with patch(RESOLVER_PATH, return_value=mock_class) as mock_resolve, \
+             patch("builtins.issubclass", return_value=True):
+            result = ResolverUtil.create_class(
+                "my_pkg.sub_pkg.my_module.MyClass", "test_source", object
+            )
+
+        mock_resolve.assert_called_once_with("MyClass", module_name="my_module")
+        self.assertIs(result, mock_class)
+
+    def test_create_class_attribute_error_raises_value_error(self):
+        """
+        If resolve_class_in_module raises AttributeError, a ValueError is raised.
+        """
+        with patch(RESOLVER_PATH, side_effect=AttributeError("not found")):
+            with self.assertRaises(ValueError):
+                ResolverUtil.create_class(
+                    "my_package.my_module.MyClass", "test_source", object
+                )
+
+    def test_create_class_wrong_type_raises_value_error(self):
+        """
+        If the resolved class is not a subclass of type_of_class, a ValueError is raised.
+        """
+        class Base:
+            """Base class for type-check testing."""
+
+        class NotBase:
+            """Class that does not inherit from Base."""
+
+        with patch(RESOLVER_PATH, return_value=NotBase):
+            with self.assertRaises(ValueError):
+                ResolverUtil.create_class(
+                    "my_package.my_module.NotBase", "test_source", Base
+                )
+
+    # -------------------------------------------------------------------------
+    # create_instance tests
+    # -------------------------------------------------------------------------
+
+    def test_create_instance_none_returns_none(self):
+        """
+        None class_name propagates through create_class and returns None.
+        """
+        result = ResolverUtil.create_instance(None, "test_source", object)
+        self.assertIsNone(result)
+
+    def test_create_instance_creates_object(self):
+        """
+        A valid class_name should produce an instance of the resolved class.
+        """
+        mock_instance = MagicMock()
+        mock_class = MagicMock(return_value=mock_instance)
+
+        with patch(RESOLVER_PATH, return_value=mock_class), \
+             patch("builtins.issubclass", return_value=True):
+            result = ResolverUtil.create_instance(
+                "my_package.my_module.MyClass", "test_source", object
+            )
+
+        mock_class.assert_called_once_with()
+        self.assertIs(result, mock_instance)
+
+    def test_create_instance_no_args_constructor_raises_value_error(self):
+        """
+        If the class cannot be instantiated without args, a ValueError is raised.
+        """
+        mock_class = MagicMock(side_effect=TypeError("__init__ requires args"))
+
+        with patch(RESOLVER_PATH, return_value=mock_class), \
+             patch("builtins.issubclass", return_value=True):
+            with self.assertRaises(ValueError):
+                ResolverUtil.create_instance(
+                    "my_package.my_module.MyClass", "test_source", object
+                )
+
+    # -------------------------------------------------------------------------
+    # create_type tests
+    # -------------------------------------------------------------------------
+
+    def test_create_type_none_returns_none(self):
+        """
+        None or empty fully_qualified_name should return None.
+        """
+        self.assertIsNone(ResolverUtil.create_type(None))
+        self.assertIsNone(ResolverUtil.create_type(""))
+
+    def test_create_type_resolves_class(self):
+        """
+        A fully qualified name should resolve to the correct class via Resolver.
+        """
+        mock_class = MagicMock()
+
+        with patch(RESOLVER_PATH, return_value=mock_class) as mock_resolve:
+            result = ResolverUtil.create_type("my_package.my_module.MyClass")
+
+        mock_resolve.assert_called_once_with(
+            "MyClass",
+            module_name="my_package.my_module",
+            raise_if_not_found=True,
+            install_if_missing=None,
+        )
+        self.assertIs(result, mock_class)
+
+    # -------------------------------------------------------------------------
+    # create_type_tuple tests
+    # -------------------------------------------------------------------------
+
+    def test_create_type_tuple_empty_list(self):
+        """
+        An empty or None type_list should return an empty tuple.
+        """
+        self.assertEqual(ResolverUtil.create_type_tuple([]), ())
+        self.assertEqual(ResolverUtil.create_type_tuple(None), ())
+
+    def test_create_type_tuple_resolves_types(self):
+        """
+        Each resolvable name in the list should appear in the returned tuple.
+        """
+        mock_class_a = MagicMock()
+        mock_class_b = MagicMock()
+
+        side_effects = [mock_class_a, mock_class_b]
+
+        with patch(RESOLVER_PATH, side_effect=side_effects):
+            result = ResolverUtil.create_type_tuple([
+                "pkg.mod.ClassA",
+                "pkg.mod.ClassB",
+            ])
+
+        self.assertEqual(len(result), 2)
+        self.assertIn(mock_class_a, result)
+        self.assertIn(mock_class_b, result)
+
+    def test_create_type_tuple_skips_unresolvable(self):
+        """
+        Types that cannot be resolved (raise_if_not_found=False) are skipped.
+        """
+        mock_class_a = MagicMock()
+
+        with patch(RESOLVER_PATH, side_effect=[mock_class_a, None]):
+            result = ResolverUtil.create_type_tuple([
+                "pkg.mod.ClassA",
+                "pkg.mod.Missing",
+            ])
+
+        self.assertEqual(len(result), 1)
+        self.assertIn(mock_class_a, result)

leaf_common-1.2.37/.github/workflows/tests.yml

@@ -1,67 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches:
-      - main
-      - "**"
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    container:
-      image: python:3.12-slim
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install dependencies
-        run: |
-          pip install -r requirements-build.txt
-          pip install -r requirements.txt
-
-      - name: Show installed packages
-        run: pip freeze
-
-      - name: Run pylint
-        run: build_scripts/run_pylint.sh
-
-      - name: Run flake8
-        run: flake8
-
-      - name: Run pytest (excluding integration tests)
-        run: pytest --verbose -m "not integration" --timer-top-n 10 --cov-config=.coveragerc --cov
-      
-      - name: Check README renders correctly on PyPI
-        run: |
-          pip install readme_renderer readme_renderer[md]
-          python -m readme_renderer README.md
-
-      - name: Notify Slack on success
-        if: success()
-        uses: slackapi/slack-github-action@v1.24.0
-        with:
-          payload: |
-            { 
-              "text": "✅ *Tests Passed* for `${{ github.repository }}` on `${{ github.ref_name }}`"
-            }
-        env:
-          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
-
-      - name: Notify Slack on failure
-        if: failure()
-        uses: slackapi/slack-github-action@v1.24.0
-        with:
-          payload: |
-            {
-              "text": "❌ *Tests Failed* for `${{ github.repository }}` on `${{ github.ref_name }}`"
-            }
-        env:
-          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
-
-