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

{leaf_common-1.2.38 → leaf_common-1.2.40}/.flake8

@@ -1,4 +1,4 @@
 [flake8]
 max-line-length = 120
-exclude = venv,venv3,.git,.idea,generated,extension_packaging.py
+exclude = venv,venv3,.git,.idea,generated,extension_packaging.py,*.egg-info
 max-complexity = 10

{leaf_common-1.2.38 → leaf_common-1.2.40}/.pylintrc

@@ -9,19 +9,18 @@
 
 # Add files or directories to the blacklist. They should be base names, not
 # paths.
-ignore=.git, extension_packaging.py
+ignore=.git, dist, extension_packaging.py
+ignore-patterns=.*egg-info
 
 # Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
 # number of processors available to use.
 jobs=0
 
-# Set reasonable line length
-max-line-length=120
-
-# When enabled, pylint would attempt to guess common misconfiguration and emit
-# user-friendly hints instead of false-positive error messages.
-suggestion-mode=yes
-
 # Not useful warning
 disable=too-few-public-methods,
         duplicate-code
+
+[FORMAT]
+
+# Set reasonable line length
+max-line-length=120

leaf_common-1.2.40/Makefile

@@ -0,0 +1,32 @@
+.DEFAULT_GOAL := help
+
+# Makefile for developer convenience only - not part of build infrastructure
+.PHONY: help install lint test check build
+
+help:
+	@echo "Makefile for developer convenience only"
+	@echo "Usage: make <target>"
+	@echo ""
+	@echo "Targets:"
+	@echo "  install       Install all dependencies (runtime + build/test)"
+	@echo "  lint          Run pylint and flake8"
+	@echo "  test          Run pytest (excluding integration tests)"
+	@echo "  check         Run lint + test (mirrors CI)"
+	@echo "  build         Build the package distribution"
+
+install:
+	pip install -r requirements-build.txt
+	pip install -r requirements.txt
+
+lint:
+	build_scripts/run_pylint.sh
+	flake8
+
+test:
+	pytest --verbose -m "not integration" --timer-top-n 10 --cov-config=.coveragerc --cov
+	rm -rf .coverage
+
+check: lint test
+
+build:
+	python -m build

{leaf_common-1.2.38 → leaf_common-1.2.40}/PKG-INFO

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

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

@@ -50,4 +50,4 @@ retval=$?
 
 echo "Pylint complete."
 
-exit ${retval}
+exit ${retval}

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

@@ -81,8 +81,9 @@ class Resolver():
             message: str = f"Could not find code for {use_module_name}"
             messages.append(message)
             for message in messages:
-                # Always print a message when we couldn't find something
-                logger.info(message)
+                # Only print a message when we couldn't find something if verbose.
+                if verbose:
+                    logger.warning(message)
             if raise_if_not_found:
                 raise ValueError(str(messages))
         elif verbose:

leaf_common-1.2.40/leaf_common/serialization/util/text_file_reader.py

@@ -0,0 +1,53 @@
+
+# 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.
+"""
+
+import asyncio
+
+from leaf_common.serialization.util.bytes_decoder import BytesDecoder
+
+
+class TextFileReader:
+    """
+    Class providing utility methods for reading text files in several possible encodings.
+    """
+
+    @staticmethod
+    def read_text_file(filepath: str) -> str:
+        """
+        Read the content of a text file in some encoding and return it as a string.
+        :param filepath: The path to the text file to read
+        :return: The content of the text file as a string
+        """
+        with open(filepath, "rb") as binary_file:
+            contents: bytes = binary_file.read()
+            text, _ = BytesDecoder.decode_bytes(contents, source_name=filepath)
+            return text
+
+    @staticmethod
+    async def async_read_text_file(filepath: str) -> str:
+        """
+        Asynchronously read the content of a text file in some encoding and return it as a string.
+
+        Implemented by offloading the blocking read to a default thread executor via
+        ``asyncio.to_thread`` to avoid an extra third-party dependency on aiofiles.
+        :param filepath: The path to the text file to read
+        :return: The content of the text file as a string
+        """
+        return await asyncio.to_thread(TextFileReader.read_text_file, filepath)

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

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

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

@@ -5,6 +5,7 @@
 CODE_OF_CONDUCT.md
 CONTRIBUTING.md
 LICENSE.txt
+Makefile
 NOTICE.txt
 README.md
 SECURITY.md
@@ -196,6 +197,7 @@ leaf_common/serialization/prep/pass_through_reference_pruner.py
 leaf_common/serialization/prep/redactor_dictionary_converter.py
 leaf_common/serialization/util/__init__.py
 leaf_common/serialization/util/bytes_decoder.py
+leaf_common/serialization/util/text_file_reader.py
 leaf_common/session/__init__.py
 leaf_common/session/abstract_service_session.py
 leaf_common/session/async_abstract_service_session.py
@@ -246,6 +248,7 @@ tests/representation/rule_based/test_rule_set.py
 tests/serialization/__init__.py
 tests/serialization/encoding/__init__.py
 tests/serialization/encoding/decode_text_test.py
+tests/serialization/encoding/text_file_reader_test.py
 tests/serialization/prep/__init__.py
 tests/serialization/prep/redactor_dictionary_converter_test.py
 tests/session/__init__.py

{leaf_common-1.2.38 → leaf_common-1.2.40}/requirements-build.txt

@@ -6,7 +6,7 @@
 hvac>=1.1.0
 
 # Tests
-pytest==8.3.3
+pytest==9.0.3
 pytest-timer==1.0.0
 timeout-decorator==0.5.0
 coverage==7.6.1

leaf_common-1.2.40/tests/serialization/encoding/text_file_reader_test.py

@@ -0,0 +1,139 @@
+
+# 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.
+"""
+
+import asyncio
+import os
+import tempfile
+from unittest import TestCase
+
+from leaf_common.serialization.util.text_file_reader import TextFileReader
+
+
+# ---------------------------------------------------------------------------
+# Encoding fixtures
+#
+# BytesDecoder tries the encodings utf-8, cp1252, latin-1 in that order and
+# returns as soon as one succeeds. The byte sequences below are chosen so
+# that each encoding's branch is exercised exactly once:
+#
+#   * utf-8     : valid UTF-8 multibyte sequence (E2 80 99 -> U+2019)
+#   * cp1252    : 0x92 -- invalid as standalone UTF-8, valid in cp1252 (U+2019)
+#   * latin-1   : 0x81 -- invalid in UTF-8 *and* in strict cp1252, valid in latin-1 (U+0081)
+# ---------------------------------------------------------------------------
+
+UTF8_BYTES = "hello ’world’".encode("utf-8")
+UTF8_EXPECTED = "hello ’world’"
+
+CP1252_BYTES = b"hello \x92world\x92"
+CP1252_EXPECTED = "hello ’world’"
+
+LATIN1_BYTES = b"hello \x81world\x81"
+LATIN1_EXPECTED = LATIN1_BYTES.decode("latin-1")
+
+
+class TextFileReaderTest(TestCase):
+    """
+    Test class for the TextFileReader utility, covering both the synchronous
+    and asynchronous read methods over all three encodings tried by BytesDecoder
+    (utf-8, cp1252, latin-1).
+    """
+
+    def setUp(self):
+        """Create a fresh temporary directory for each test."""
+        # pylint: disable=consider-using-with
+        self._tmp_dir = tempfile.TemporaryDirectory()
+        self.tmp_path = self._tmp_dir.name
+
+    def tearDown(self):
+        """Clean up the temporary directory created in setUp."""
+        self._tmp_dir.cleanup()
+
+    def _write_bytes(self, content: bytes, filename: str = "sample.txt") -> str:
+        """Write raw bytes to a file in the per-test temp directory and return its path."""
+        path = os.path.join(self.tmp_path, filename)
+        with open(path, "wb") as fileobj:
+            fileobj.write(content)
+        return path
+
+    # -----------------------------------------------------------------------
+    # read_text_file (synchronous)
+    # -----------------------------------------------------------------------
+
+    def test_read_text_file_decodes_utf8(self):
+        """A UTF-8 encoded file is decoded via the utf-8 branch."""
+        path = self._write_bytes(UTF8_BYTES)
+        self.assertEqual(TextFileReader.read_text_file(path), UTF8_EXPECTED)
+
+    def test_read_text_file_decodes_cp1252(self):
+        """A cp1252-only byte sequence falls through utf-8 and is decoded as cp1252."""
+        path = self._write_bytes(CP1252_BYTES)
+        self.assertEqual(TextFileReader.read_text_file(path), CP1252_EXPECTED)
+
+    def test_read_text_file_decodes_latin1(self):
+        """A latin-1-only byte sequence falls through utf-8 and cp1252, decoded as latin-1."""
+        path = self._write_bytes(LATIN1_BYTES)
+        self.assertEqual(TextFileReader.read_text_file(path), LATIN1_EXPECTED)
+
+    def test_read_text_file_empty_file_returns_empty_string(self):
+        """An empty file decodes to an empty string."""
+        path = self._write_bytes(b"")
+        self.assertEqual(TextFileReader.read_text_file(path), "")
+
+    def test_read_text_file_raises_file_not_found(self):
+        """A missing file raises FileNotFoundError."""
+        with self.assertRaises(FileNotFoundError):
+            TextFileReader.read_text_file(os.path.join(self.tmp_path, "does_not_exist.txt"))
+
+    # -----------------------------------------------------------------------
+    # async_read_text_file
+    # -----------------------------------------------------------------------
+
+    def test_async_read_text_file_decodes_utf8(self):
+        """A UTF-8 encoded file is decoded via the utf-8 branch (async)."""
+        path = self._write_bytes(UTF8_BYTES)
+        result = asyncio.run(TextFileReader.async_read_text_file(path))
+        self.assertEqual(result, UTF8_EXPECTED)
+
+    def test_async_read_text_file_decodes_cp1252(self):
+        """A cp1252-only byte sequence falls through utf-8 and is decoded as cp1252 (async)."""
+        path = self._write_bytes(CP1252_BYTES)
+        result = asyncio.run(TextFileReader.async_read_text_file(path))
+        self.assertEqual(result, CP1252_EXPECTED)
+
+    def test_async_read_text_file_decodes_latin1(self):
+        """A latin-1-only byte sequence falls through utf-8 and cp1252, decoded as latin-1 (async)."""
+        path = self._write_bytes(LATIN1_BYTES)
+        result = asyncio.run(TextFileReader.async_read_text_file(path))
+        self.assertEqual(result, LATIN1_EXPECTED)
+
+    def test_async_read_text_file_empty_file_returns_empty_string(self):
+        """An empty file decodes to an empty string (async)."""
+        path = self._write_bytes(b"")
+        result = asyncio.run(TextFileReader.async_read_text_file(path))
+        self.assertEqual(result, "")
+
+    def test_async_read_text_file_raises_file_not_found(self):
+        """A missing file raises FileNotFoundError (async)."""
+        with self.assertRaises(FileNotFoundError):
+            asyncio.run(
+                TextFileReader.async_read_text_file(
+                    os.path.join(self.tmp_path, "does_not_exist.txt")
+                )
+            )