snowpark-checkpoints-configuration 0.1.4__tar.gz → 0.2.0__tar.gz

{snowpark_checkpoints_configuration-0.1.4 → snowpark_checkpoints_configuration-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowpark-checkpoints-configuration
-Version: 0.1.4
+Version: 0.2.0
 Summary: Migration tools for Snowpark
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowpark-checkpoints/issues
 Project-URL: Source code, https://github.com/snowflakedb/snowpark-checkpoints/

{snowpark_checkpoints_configuration-0.1.4 → snowpark_checkpoints_configuration-0.2.0}/src/snowflake/snowpark_checkpoints_configuration/__init__.py

@@ -13,10 +13,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
+
+
+# Add a NullHandler to prevent logging messages from being output to
+# sys.stderr if no logging configuration is provided.
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+# ruff: noqa: E402
+
 from snowflake.snowpark_checkpoints_configuration.checkpoint_metadata import (
     CheckpointMetadata,
 )
 
+
 __all__ = [
     "CheckpointMetadata",
 ]

{snowpark_checkpoints_configuration-0.1.4 → snowpark_checkpoints_configuration-0.2.0}/src/snowflake/snowpark_checkpoints_configuration/__version__.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.1.4"
+__version__ = "0.2.0"

{snowpark_checkpoints_configuration-0.1.4 → snowpark_checkpoints_configuration-0.2.0}/src/snowflake/snowpark_checkpoints_configuration/checkpoint_metadata.py

@@ -12,8 +12,12 @@
 # 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.
+
+import logging
 import os
 
+from typing import Optional
+
 from snowflake.snowpark_checkpoints_configuration.model.checkpoints import (
     Checkpoint,
     Checkpoints,
@@ -21,6 +25,9 @@ from snowflake.snowpark_checkpoints_configuration.model.checkpoints import (
 from snowflake.snowpark_checkpoints_configuration.singleton import Singleton
 
 
+LOGGER = logging.getLogger(__name__)
+
+
 class CheckpointMetadata(metaclass=Singleton):
 
     """CheckpointMetadata class.
@@ -33,21 +40,28 @@ class CheckpointMetadata(metaclass=Singleton):
 
     """
 
-    def __init__(self, path: str = None):
-        directory = path if path is not None else os.getcwd()
+    def __init__(self, path: Optional[str] = None):
         self.checkpoint_model: Checkpoints = Checkpoints(type="", pipelines=[])
+        directory = path if path is not None else os.getcwd()
         checkpoints_file = os.path.join(directory, "checkpoints.json")
         if os.path.exists(checkpoints_file):
-            with open(checkpoints_file) as f:
-                try:
+            LOGGER.info("Reading checkpoints file: '%s'", checkpoints_file)
+            try:
+                with open(checkpoints_file) as f:
                     checkpoint_json = f.read()
                     self.checkpoint_model = Checkpoints.model_validate_json(
                         checkpoint_json
                     )
-                except Exception as e:
-                    raise Exception(
-                        f"Error reading checkpoints file: {checkpoints_file} \n {e}"
-                    ) from None
+                LOGGER.info(
+                    "Successfully read and validated checkpoints file: '%s'",
+                    checkpoints_file,
+                )
+            except Exception as e:
+                error_msg = f"An error occurred while reading the checkpoints file: '{checkpoints_file}'"
+                LOGGER.exception(error_msg)
+                raise Exception(f"{error_msg} \n {e}") from None
+        else:
+            LOGGER.warning("Checkpoints file not found: '%s'", checkpoints_file)
 
     def get_checkpoint(self, checkpoint_name: str) -> Checkpoint:
         """Get a checkpoint by its name.

{snowpark_checkpoints_configuration-0.1.4 → snowpark_checkpoints_configuration-0.2.0}/src/snowflake/snowpark_checkpoints_configuration/model/checkpoints.py

@@ -13,6 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
+
 from typing import Optional
 
 from pydantic import BaseModel, ConfigDict, field_validator
@@ -21,6 +23,9 @@ from pydantic.alias_generators import to_camel
 from snowflake.snowpark_checkpoints_configuration import checkpoint_name_utils
 
 
+LOGGER = logging.getLogger(__name__)
+
+
 class Checkpoint(BaseModel):
 
     """Checkpoint model.
@@ -42,15 +47,19 @@ class Checkpoint(BaseModel):
     @field_validator("name", mode="before")
     @classmethod
     def normalize(cls, name: str) -> str:
+        LOGGER.debug("Normalizing checkpoint name: '%s'", name)
         normalized_name = checkpoint_name_utils.normalize_checkpoint_name(name)
+        LOGGER.debug("Checkpoint name was normalized to: '%s'", normalized_name)
         is_valid_checkpoint_name = checkpoint_name_utils.is_valid_checkpoint_name(
             normalized_name
         )
         if not is_valid_checkpoint_name:
-            raise Exception(
-                f"Invalid checkpoint name: {name} in checkpoints.json file. Checkpoint names must only contain "
-                f"alphanumeric characters and underscores."
+            error_msg = (
+                f"Invalid checkpoint name: {name} in checkpoints.json file. "
+                f"Checkpoint names must only contain alphanumeric characters and underscores."
             )
+            LOGGER.error(error_msg)
+            raise Exception(error_msg)
 
         return normalized_name
 
@@ -93,8 +102,11 @@ class Checkpoints(BaseModel):
     _checkpoints = {}
 
     def _build_checkpoints_dict(self):
+        LOGGER.debug("Building checkpoints dictionary from pipelines.")
         for pipeline in self.pipelines:
+            LOGGER.debug("Processing pipeline: '%s'", pipeline.entry_point)
             for checkpoint in pipeline.checkpoints:
+                LOGGER.debug("Adding checkpoint: %s", checkpoint)
                 self._checkpoints[checkpoint.name] = checkpoint
 
     def get_check_point(self, checkpoint_name: str) -> Checkpoint:
@@ -108,21 +120,35 @@ class Checkpoints(BaseModel):
             with the name set to the checkpoint_id.
 
         """
+        LOGGER.info("Fetching checkpoint: '%s'", checkpoint_name)
         if not self._checkpoints:
+            LOGGER.debug("Checkpoints dictionary is empty, building it...")
             self._build_checkpoints_dict()
 
         checkpoint = self._checkpoints.get(checkpoint_name)
         if len(self._checkpoints) == 0:
+            LOGGER.info(
+                "No checkpoints found, creating a new enabled checkpoint with name: '%s'",
+                checkpoint_name,
+            )
             checkpoint = Checkpoint(name=checkpoint_name, enabled=True)
         elif checkpoint is None:
+            LOGGER.info(
+                "Checkpoint not found, creating a new disabled checkpoint with name: '%s'",
+                checkpoint_name,
+            )
             checkpoint = Checkpoint(name=checkpoint_name, enabled=False)
+
+        LOGGER.debug("Returning checkpoint: %s", checkpoint)
         return checkpoint
 
     def add_checkpoint(self, checkpoint: Checkpoint) -> None:
         """Add a checkpoint to the checkpoints' dictionary.
 
-        Args:.
+        Args:
             checkpoint (Checkpoint): The checkpoint object to add
 
         """
+        LOGGER.debug("Adding checkpoint: %s", checkpoint)
         self._checkpoints[checkpoint.name] = checkpoint
+        LOGGER.info("Checkpoint '%s' added successfully.", checkpoint.name)

{snowpark_checkpoints_configuration-0.1.4 → snowpark_checkpoints_configuration-0.2.0}/test/unit/test_checkpoint_metadata.py

@@ -12,6 +12,8 @@
 # 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.
+
+import logging
 import os.path
 import tempfile
 
@@ -28,12 +30,16 @@ from snowflake.snowpark_checkpoints_configuration.model.checkpoints import (
 from snowflake.snowpark_checkpoints_configuration.singleton import Singleton
 
 
-@pytest.fixture
+@pytest.fixture(autouse=True)
 def singleton():
     Singleton._instances = {}
 
 
-def test_checkpoint_metadata_loading(singleton):
+LOGGER_NAME = "snowflake.snowpark_checkpoints_configuration.checkpoint_metadata"
+
+
+def test_checkpoint_metadata_loading(caplog: pytest.LogCaptureFixture):
+    caplog.set_level(level=logging.INFO, logger=LOGGER_NAME)
     path = os.path.dirname(os.path.abspath(__file__))
     path = os.path.join(path, "valid_checkpoint")
     metadata = CheckpointMetadata(path)
@@ -62,26 +68,34 @@ def test_checkpoint_metadata_loading(singleton):
 
     expected_checkpoints = Checkpoints(type="Collection", pipelines=[expected_pipeline])
     assert metadata.checkpoint_model == expected_checkpoints
+    assert "Successfully read and validated checkpoints file" in caplog.text
 
 
-def test_checkpoint_metadata_loading_no_file(singleton):
+def test_checkpoint_metadata_loading_no_file(caplog: pytest.LogCaptureFixture):
+    caplog.set_level(level=logging.WARNING, logger=LOGGER_NAME)
     path = tempfile.gettempdir()
     metadata = CheckpointMetadata(path)
     expected_checkpoints = Checkpoints(type="", pipelines=[])
     assert metadata.checkpoint_model == expected_checkpoints
+    assert "Checkpoints file not found" in caplog.text
 
 
-def test_checkpoint_metadata_loading_invalid_file(singleton):
+def test_checkpoint_metadata_loading_invalid_file(caplog: pytest.LogCaptureFixture):
+    caplog.set_level(level=logging.ERROR, logger=LOGGER_NAME)
     path = os.path.dirname(os.path.abspath(__file__))
     path = os.path.join(path, "invalid_checkpoint")
     checkpoint_file_name = os.path.join(path, "checkpoints.json")
-    expected_exception = f"Error reading checkpoints file: {checkpoint_file_name} \n"
+    expected_error_msg = f"An error occurred while reading the checkpoints file: '{checkpoint_file_name}'"
     with pytest.raises(Exception) as ex_info:
         CheckpointMetadata(path)
-    assert str(ex_info.value).startswith(expected_exception)
+    assert str(ex_info.value).startswith(expected_error_msg)
+    assert expected_error_msg in caplog.text
+    assert any(
+        record.exc_info is not None for record in caplog.records
+    ), "Log message does not contain the exception details, but it should"
 
 
-def test_checkpoint_metadata_get_checkpoint_exist(singleton):
+def test_checkpoint_metadata_get_checkpoint_exist():
     path = os.path.dirname(os.path.abspath(__file__))
     path = os.path.join(path, "valid_checkpoint")
     metadata = CheckpointMetadata(path)
@@ -98,7 +112,7 @@ def test_checkpoint_metadata_get_checkpoint_exist(singleton):
     assert checkpoint == expected_checkpoint
 
 
-def test_checkpoint_metadata_get_checkpoint_not_exist(singleton):
+def test_checkpoint_metadata_get_checkpoint_not_exist():
     path = os.path.dirname(os.path.abspath(__file__))
     path = os.path.join(path, "valid_checkpoint")
     metadata = CheckpointMetadata(path)
@@ -107,7 +121,7 @@ def test_checkpoint_metadata_get_checkpoint_not_exist(singleton):
     assert checkpoint == expected_checkpoint
 
 
-def test_checkpoint_metadata_get_checkpoint_no_file(singleton):
+def test_checkpoint_metadata_get_checkpoint_no_file():
     path = tempfile.gettempdir()
     metadata = CheckpointMetadata(path)
     checkpoint = metadata.get_checkpoint("not-exist-checkpoint")

{snowpark_checkpoints_configuration-0.1.4 → snowpark_checkpoints_configuration-0.2.0}/test/unit/test_checkpoint_name_utils.py

@@ -12,6 +12,9 @@
 # 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.
+
+import logging
+
 import pytest
 
 from snowflake.snowpark_checkpoints_configuration.model.checkpoints import (
@@ -19,6 +22,9 @@ from snowflake.snowpark_checkpoints_configuration.model.checkpoints import (
 )
 
 
+LOGGER_NAME = "snowflake.snowpark_checkpoints_configuration.model.checkpoints"
+
+
 @pytest.mark.parametrize(
     "input_value,expected_value",
     [("my checkpoint", "my_checkpoint"), ("my  checkpoint ", "my__checkpoint_")],
@@ -73,10 +79,14 @@ def test_validate_checkpoint_name_valid_case(input_value):
     assert checkpoint.name == input_value
 
 
-@pytest.mark.parametrize(
-    "input_value", ["_", "5", "", "56_my_checkpoint", "my-check", "_+check"]
-)
-def test_checkpoint_invalid_name(input_value):
+@pytest.mark.parametrize("input_value", ["_", "5", "", "56_my_checkpoint", "_+check"])
+def test_checkpoint_invalid_name(input_value: str, caplog: pytest.LogCaptureFixture):
+    caplog.set_level(level=logging.ERROR, logger=LOGGER_NAME)
+    expected_error_msg = (
+        f"Invalid checkpoint name: {input_value} in checkpoints.json file. "
+        f"Checkpoint names must only contain alphanumeric characters and underscores."
+    )
+
     with pytest.raises(Exception) as ex_info:
         Checkpoint(
             name=input_value,
@@ -87,7 +97,6 @@ def test_checkpoint_invalid_name(input_value):
             location=1,
             enabled=True,
         )
-        assert (
-            f"Invalid checkpoint name: {Checkpoint.name}. Checkpoint names must only contain alphanumeric "
-            f"characters and underscores."
-        ) == str(ex_info.value)
+
+    assert str(ex_info.value).startswith(expected_error_msg)
+    assert expected_error_msg in caplog.text

{snowpark_checkpoints_configuration-0.1.4 → snowpark_checkpoints_configuration-0.2.0}/test/unit/test_checkpoints.py

@@ -13,6 +13,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
+import pytest
+
 from snowflake.snowpark_checkpoints_configuration.model.checkpoints import (
     Checkpoint,
     Checkpoints,
@@ -20,8 +23,13 @@ from snowflake.snowpark_checkpoints_configuration.model.checkpoints import (
 )
 
 
-def test_add_checkpoint():
+LOGGER_NAME = "snowflake.snowpark_checkpoints_configuration.model.checkpoints"
+
+
+def test_add_checkpoint(caplog: pytest.LogCaptureFixture):
+    caplog.set_level(level=logging.DEBUG, logger=LOGGER_NAME)
     checkpoints = Checkpoints(type="Collection", pipelines=[])
+    normalized_checkpoint_name = "checkpoint_name"
     new_checkpoint = Checkpoint(
         name="checkpoint-name",
         df="df",
@@ -32,7 +40,10 @@ def test_add_checkpoint():
         enabled=False,
     )
     checkpoints.add_checkpoint(new_checkpoint)
-    assert checkpoints.get_check_point("checkpoint_name") == new_checkpoint
+    assert checkpoints.get_check_point(normalized_checkpoint_name) == new_checkpoint
+    assert (
+        f"Checkpoint '{normalized_checkpoint_name}' added successfully" in caplog.text
+    )
 
 
 def test_add_checkpoint_with_same_name():
@@ -87,9 +98,30 @@ def test_get_checkpoint_existing():
     assert checkpoints.get_check_point("checkpoint_name") == expected_checkpoint
 
 
-def test_get_checkpoint_non_existing():
+def test_get_checkpoint_non_existing_empty_dict(caplog: pytest.LogCaptureFixture):
+    caplog.set_level(level=logging.DEBUG, logger=LOGGER_NAME)
     checkpoints = Checkpoints(type="Collection", pipelines=[])
+    checkpoint_name = "checkpoint-name-2"
+    checkpoint = checkpoints.get_check_point(checkpoint_name)
+    assert checkpoint == Checkpoint(name=checkpoint_name, enabled=True)
+    assert "creating a new enabled checkpoint" in caplog.text
+
 
-    assert checkpoints.get_check_point("checkpoint-name-2") == Checkpoint(
-        name="checkpoint-name-2", enabled=True
+def test_get_checkpoint_no_existing_non_empty_dict(caplog: pytest.LogCaptureFixture):
+    caplog.set_level(level=logging.INFO, logger=LOGGER_NAME)
+    checkpoint = Checkpoint(
+        name="checkpoint_name_1",
+        df="df",
+        mode=1,
+        function="",
+        file="file",
+        location=1,
+        enabled=False,
     )
+    pipeline = Pipeline(entry_point="entry-point", checkpoints=[checkpoint])
+    checkpoints = Checkpoints(type="Collection", pipelines=[pipeline])
+    checkpoint_name = "checkpoint_name_2"
+    checkpoint = checkpoints.get_check_point(checkpoint_name)
+
+    assert checkpoint == Checkpoint(name=checkpoint_name, enabled=False)
+    assert "creating a new disabled checkpoint" in caplog.text

snowpark_checkpoints_configuration-0.2.0/test/unit/test_logger.py

@@ -0,0 +1,128 @@
+# Copyright 2025 Snowflake Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# 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.
+
+import io
+import logging
+
+from collections.abc import Generator
+from importlib import import_module
+from typing import Any, Union
+
+import pytest
+
+
+TOP_LEVEL_LOGGER_NAME = "snowflake.snowpark_checkpoints_configuration"
+
+LoggerDict = dict[str, Union[logging.Logger, logging.PlaceHolder]]
+LoggerGenerator = Generator[logging.Logger, Any, None]
+
+
+@pytest.fixture(name="registered_loggers", scope="module")
+def fixture_registered_loggers() -> LoggerDict:
+    """Return a dictionary with all the registered loggers."""
+    # We need to import the snowflake.snowpark_checkpoints_configuration module
+    # to ensure the __init__.py file is executed.
+    import_module("snowflake.snowpark_checkpoints_configuration")
+
+    return logging.getLogger().manager.loggerDict
+
+
+@pytest.fixture(name="top_level_logger", scope="module")
+def fixture_top_level_logger(registered_loggers: LoggerDict) -> LoggerGenerator:
+    """Return the top-level logger of the snowpark-checkpoints-configuration package."""
+    logger = registered_loggers.get(TOP_LEVEL_LOGGER_NAME, None)
+    assert isinstance(logger, logging.Logger)
+
+    # Save the original state of the logger
+    original_handlers = logger.handlers
+    original_propagate = logger.propagate
+    original_level = logger.level
+    original_filters = logger.filters
+
+    yield logger
+
+    # Restore the original state of the logger
+    logger.handlers = original_handlers
+    logger.propagate = original_propagate
+    logger.setLevel(original_level)
+    logger.filters = original_filters
+
+
+def test_loggers_exists(registered_loggers: LoggerDict):
+    """Validates that all the snowflake.snowpark_checkpoints_configuration loggers exist."""
+    logger_names = {
+        "snowflake.snowpark_checkpoints_configuration",
+        "snowflake.snowpark_checkpoints_configuration.checkpoint_metadata",
+        "snowflake.snowpark_checkpoints_configuration.model.checkpoints",
+    }
+
+    for logger_name in logger_names:
+        logger = registered_loggers.get(logger_name, None)
+        assert logger is not None
+        assert isinstance(logger, logging.Logger)
+
+
+def test_top_level_logger_has_null_handler(top_level_logger: LoggerGenerator):
+    """Validates that the top-level logger has a single handler and that it is a NullHandler."""
+    assert isinstance(top_level_logger, logging.Logger)
+    assert len(top_level_logger.handlers) == 1
+    assert isinstance(top_level_logger.handlers[0], logging.NullHandler)
+
+
+def test_top_level_logger_default_log_level(top_level_logger: LoggerGenerator):
+    """Validates that the default log level of the top-level logger is logging.WARNING."""
+    assert isinstance(top_level_logger, logging.Logger)
+    assert top_level_logger.getEffectiveLevel() == logging.WARNING
+
+
+def test_child_logger_inheritance(
+    registered_loggers: LoggerDict, top_level_logger: LoggerGenerator
+):
+    """Validates the inheritance of the loggers."""
+    child_logger = registered_loggers.get(
+        f"{TOP_LEVEL_LOGGER_NAME}.checkpoint_metadata", None
+    )
+    assert isinstance(child_logger, logging.Logger)
+    assert child_logger.parent == top_level_logger
+
+
+def test_log_propagation(
+    registered_loggers: LoggerDict, top_level_logger: LoggerGenerator
+):
+    """Validates that log messages are propagated from a child logger to the top-level logger."""
+    assert isinstance(top_level_logger, logging.Logger)
+
+    stream_handler = logging.StreamHandler(io.StringIO())
+    top_level_logger.addHandler(stream_handler)
+
+    child_logger = registered_loggers.get(
+        f"{TOP_LEVEL_LOGGER_NAME}.checkpoint_metadata", None
+    )
+    assert isinstance(child_logger, logging.Logger)
+    assert len(child_logger.handlers) == 0
+
+    child_logger.warning("Test message")
+    assert "Test message" in stream_handler.stream.getvalue()
+
+
+def test_null_handler_supresses_output(
+    capsys: pytest.CaptureFixture[str], top_level_logger: LoggerGenerator
+):
+    """Validates that NullHandler suppresses output to stderr."""
+    assert isinstance(top_level_logger, logging.Logger)
+    top_level_logger.propagate = False
+    top_level_logger.error("This should not appear in stderr")
+    captured = capsys.readouterr()
+    assert captured.err == ""