snowpark-checkpoints-configuration 0.2.0rc1__py3-none-any.whl → 0.3.0__py3-none-any.whl

snowflake/snowpark_checkpoints_configuration/__init__.py

@@ -0,0 +1,32 @@
+# 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 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",
+]

snowflake/snowpark_checkpoints_configuration/__version__.py

@@ -0,0 +1,16 @@
+# 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.
+
+__version__ = "0.3.0"

snowflake/snowpark_checkpoints_configuration/checkpoint_metadata.py

@@ -0,0 +1,76 @@
+# 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 logging
+import os
+
+from typing import Optional
+
+from snowflake.snowpark_checkpoints_configuration.io_utils.io_file_manager import (
+    get_io_file_manager,
+)
+from snowflake.snowpark_checkpoints_configuration.model.checkpoints import (
+    Checkpoint,
+    Checkpoints,
+)
+from snowflake.snowpark_checkpoints_configuration.singleton import Singleton
+
+
+LOGGER = logging.getLogger(__name__)
+
+
+class CheckpointMetadata(metaclass=Singleton):
+
+    """CheckpointMetadata class.
+
+    This is a singleton class that reads the checkpoints.json file
+    and provides an interface to get the checkpoint configuration.
+
+    Args:
+        metaclass (Singleton, optional): Defaults to Singleton.
+
+    """
+
+    def __init__(self, path: Optional[str] = None):
+        self.checkpoint_model: Checkpoints = Checkpoints(type="", pipelines=[])
+        directory = path if path is not None else get_io_file_manager().getcwd()
+        checkpoints_file = os.path.join(directory, "checkpoints.json")
+        if get_io_file_manager().file_exists(checkpoints_file):
+            LOGGER.info("Reading checkpoints file: '%s'", checkpoints_file)
+            try:
+                checkpoint_json = get_io_file_manager().read(checkpoints_file)
+                self.checkpoint_model = Checkpoints.model_validate_json(checkpoint_json)
+                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.
+
+        Args:
+            checkpoint_name (str): checkpoint name
+
+        Returns:
+            Checkpoint: Checkpoint configuration instance
+
+        """
+        return self.checkpoint_model.get_check_point(checkpoint_name=checkpoint_name)

snowflake/snowpark_checkpoints_configuration/checkpoint_name_utils.py

@@ -0,0 +1,53 @@
+# 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 re as regx
+
+
+CHECKPOINT_NAME_REGEX_PATTERN = r"[a-zA-Z_][a-zA-Z0-9_$]+"
+TRANSLATION_TABLE = str.maketrans({" ": "_", "-": "_"})
+
+
+def normalize_checkpoint_name(checkpoint_name: str) -> str:
+    """Normalize the provided checkpoint name by replacing: the whitespace and hyphen tokens by underscore token.
+
+    Args:
+        checkpoint_name (str): The checkpoint name to normalize.
+
+    Returns:
+        str: the checkpoint name normalized.
+
+    """
+    normalized_checkpoint_name = checkpoint_name.translate(TRANSLATION_TABLE)
+    return normalized_checkpoint_name
+
+
+def is_valid_checkpoint_name(checkpoint_name: str) -> bool:
+    """Check if the provided checkpoint name is valid.
+
+    A valid checkpoint name must:
+    - Start with a letter (a-z, A-Z) or an underscore (_)
+    - Be followed by any combination of letters, digits (0-9), underscores (_), and dollar signs ($).
+
+    Args:
+        checkpoint_name (str): The checkpoint name to validate.
+
+    Returns:
+        bool: True if the checkpoint name is valid; otherwise, False.
+
+    """
+    matched = regx.fullmatch(CHECKPOINT_NAME_REGEX_PATTERN, checkpoint_name)
+    is_valid = bool(matched)
+    return is_valid

snowflake/snowpark_checkpoints_configuration/io_utils/__init__.py

@@ -0,0 +1,26 @@
+# 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.
+
+__all__ = ["EnvStrategy", "IOFileManager", "IODefaultStrategy"]
+
+from snowflake.snowpark_checkpoints_configuration.io_utils.io_env_strategy import (
+    EnvStrategy,
+)
+from snowflake.snowpark_checkpoints_configuration.io_utils.io_default_strategy import (
+    IODefaultStrategy,
+)
+from snowflake.snowpark_checkpoints_configuration.io_utils.io_file_manager import (
+    IOFileManager,
+)

snowflake/snowpark_checkpoints_configuration/io_utils/io_default_strategy.py

@@ -0,0 +1,34 @@
+# 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 os
+
+from typing import Optional
+
+from snowflake.snowpark_checkpoints_configuration.io_utils import EnvStrategy
+
+
+class IODefaultStrategy(EnvStrategy):
+    def file_exists(self, path: str) -> bool:
+        return os.path.isfile(path)
+
+    def read(
+        self, file_path: str, mode: str = "r", encoding: Optional[str] = None
+    ) -> str:
+        with open(file_path, mode=mode, encoding=encoding) as file:
+            return file.read()
+
+    def getcwd(self) -> str:
+        return os.getcwd()

snowflake/snowpark_checkpoints_configuration/io_utils/io_env_strategy.py

@@ -0,0 +1,62 @@
+# 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.
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class EnvStrategy(ABC):
+
+    """An abstract base class that defines methods for file and directory operations.
+
+    Subclasses should implement these methods to provide environment-specific behavior.
+    """
+
+    @abstractmethod
+    def file_exists(self, path: str) -> bool:
+        """Check if a file exists.
+
+        Args:
+            path: The path to the file.
+
+        Returns:
+            bool: True if the file exists, False otherwise.
+
+        """
+
+    @abstractmethod
+    def read(
+        self, file_path: str, mode: str = "r", encoding: Optional[str] = None
+    ) -> str:
+        """Read content from a file.
+
+        Args:
+            file_path: The path to the file to read from.
+            mode: The mode in which to open the file.
+            encoding: The encoding to use for reading the file.
+
+        Returns:
+            str: The content of the file.
+
+        """
+
+    @abstractmethod
+    def getcwd(self) -> str:
+        """Get the current working directory.
+
+        Returns:
+            str: The current working directory.
+
+        """

snowflake/snowpark_checkpoints_configuration/io_utils/io_file_manager.py

@@ -0,0 +1,57 @@
+# 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.
+
+from typing import Optional
+
+from snowflake.snowpark_checkpoints_configuration.io_utils import (
+    EnvStrategy,
+    IODefaultStrategy,
+)
+from snowflake.snowpark_checkpoints_configuration.singleton import Singleton
+
+
+class IOFileManager(metaclass=Singleton):
+    def __init__(self, strategy: Optional[EnvStrategy] = None):
+        self.strategy = strategy or IODefaultStrategy()
+
+    def file_exists(self, path: str) -> bool:
+        return self.strategy.file_exists(path)
+
+    def read(
+        self, file_path: str, mode: str = "r", encoding: Optional[str] = None
+    ) -> str:
+        return self.strategy.read(file_path, mode, encoding)
+
+    def getcwd(self) -> str:
+        return self.strategy.getcwd()
+
+    def set_strategy(self, strategy: EnvStrategy):
+        """Set the strategy for file and directory operations.
+
+        Args:
+            strategy (EnvStrategy): The strategy to use for file and directory operations.
+
+        """
+        self.strategy = strategy
+
+
+def get_io_file_manager():
+    """Get the singleton instance of IOFileManager.
+
+    Returns:
+        IOFileManager: The singleton instance of IOFileManager.
+
+    """
+    return IOFileManager()

snowflake/snowpark_checkpoints_configuration/model/checkpoints.py

@@ -0,0 +1,154 @@
+# 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 logging
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, field_validator
+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.
+
+    Args:
+        pydantic.BaseModel (pydantic.BaseModel): pydantic BaseModel
+
+    """
+
+    name: str
+    mode: int = 1
+    function: Optional[str] = None
+    df: Optional[str] = None
+    sample: Optional[float] = None
+    file: Optional[str] = None
+    location: int = -1
+    enabled: bool = True
+
+    @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:
+            error_msg = (
+                f"Invalid checkpoint name: {name} in checkpoints.json file. "
+                f"Checkpoint names must only contain alphanumeric characters, underscores and dollar signs."
+            )
+            LOGGER.error(error_msg)
+            raise Exception(error_msg)
+
+        return normalized_name
+
+
+class Pipeline(BaseModel):
+
+    """Pipeline model.
+
+    Args:
+        pydantic.BaseModel (pydantic.BaseModel): pydantic BaseModel
+
+    """
+
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        populate_by_name=True,
+        from_attributes=True,
+    )
+
+    entry_point: str
+    checkpoints: list[Checkpoint]
+
+
+class Checkpoints(BaseModel):
+
+    """Checkpoints model.
+
+    Args:
+        pydantic.BaseModel (pydantic.BaseModel): pydantic BaseModel
+
+    Returns:
+        Checkpoints: An instance of the Checkpoints class
+
+    """
+
+    type: str
+    pipelines: list[Pipeline]
+
+    # this dictionary holds the unpacked checkpoints from the different pipelines.
+    _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:
+        """Get a checkpoint by its name.
+
+        Args:
+            checkpoint_name (str): The name of the checkpoint.
+
+        Returns:
+            Checkpoint: The checkpoint object if found, otherwise a new Checkpoint object
+            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:
+            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)

snowflake/snowpark_checkpoints_configuration/singleton.py

@@ -0,0 +1,23 @@
+# 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.
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]

snowpark_checkpoints_configuration-0.3.0.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: snowpark-checkpoints-configuration
+Version: 0.3.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/
+Author-email: "Snowflake, Inc." <snowflake-python-libraries-dl@snowflake.com>
+License: Apache License, Version 2.0
+License-File: LICENSE
+Keywords: Snowflake,Snowpark,analytics,cloud,database,db
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: SQL
+Classifier: Topic :: Database
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <3.12,>=3.9
+Requires-Dist: pydantic>=1.8.2
+Requires-Dist: snowflake-snowpark-python>=1.23.0
+Provides-Extra: development
+Requires-Dist: certifi==2025.1.31; extra == 'development'
+Requires-Dist: coverage>=7.6.7; extra == 'development'
+Requires-Dist: hatchling==1.25.0; extra == 'development'
+Requires-Dist: pre-commit>=4.0.1; extra == 'development'
+Requires-Dist: pyarrow>=18.0.0; extra == 'development'
+Requires-Dist: pytest-cov>=6.0.0; extra == 'development'
+Requires-Dist: pytest>=8.3.3; extra == 'development'
+Requires-Dist: setuptools>=70.0.0; extra == 'development'
+Requires-Dist: twine==5.1.1; extra == 'development'
+Description-Content-Type: text/markdown
+
+# snowpark-checkpoints-configuration
+
+---
+##### This package is on Public Preview.
+---
+**snowpark-checkpoints-configuration** is a module for loading `checkpoint.json` and provides a model. 
+This module will work automatically with *snowpark-checkpoints-collector*  and *snowpark-checkpoints-validators*. This will try to read the configuration file from the current working directory.
+
+## Usage
+
+To explicit load a file, you can import  `CheckpointMetadata` and create an instance as shown below:
+
+```python
+from snowflake.snowpark_checkpoints_configuration import CheckpointMetadata
+
+my_checkpoint_metadata = CheckpointMetadata("path/to/checkpoint.json")
+
+checkpoint_model = my_checkpoint_metadata.get_checkpoint("my_checkpoint_name")
+...
+```
+------

snowpark_checkpoints_configuration-0.3.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+snowflake/snowpark_checkpoints_configuration/__init__.py,sha256=xZ2oBwJeEso0laWYDaXQidGt_MdjgNsOZ1_0BcZcXvE,980
+snowflake/snowpark_checkpoints_configuration/__version__.py,sha256=kbbDnlkY7JOLNHvfWYkCO_mOBOV9GniMGdxYoQpLhyg,632
+snowflake/snowpark_checkpoints_configuration/checkpoint_metadata.py,sha256=fdmZpZxzqwtYfCjwjkl_9M8Z1hY04f_vE05HfGVRQc4,2773
+snowflake/snowpark_checkpoints_configuration/checkpoint_name_utils.py,sha256=Xc4k3JU6A96-79VFRR8NrNAUPeO3V1DEAhngg-hLlU4,1787
+snowflake/snowpark_checkpoints_configuration/singleton.py,sha256=7AgIHQBXVRvPBBCkmBplzkdrrm-xVWf_N8svzA2vF8E,836
+snowflake/snowpark_checkpoints_configuration/io_utils/__init__.py,sha256=UgACTfonQw5bMAAuU_CrtVTzVVKxxK6NEDOogNl2qJM,996
+snowflake/snowpark_checkpoints_configuration/io_utils/io_default_strategy.py,sha256=TX0xhezFmO5f37SsNP8nhsfAfRWJ2YwYPOE_pefJvsg,1113
+snowflake/snowpark_checkpoints_configuration/io_utils/io_env_strategy.py,sha256=h6gjwBqOhyJHxAvWa7kL4jvyqF31ssTWGkQCAH99rd8,1735
+snowflake/snowpark_checkpoints_configuration/io_utils/io_file_manager.py,sha256=H_xNLycfia2R_35xF1ery41i1BqFzysEuQjkL5sZeEs,1782
+snowflake/snowpark_checkpoints_configuration/model/checkpoints.py,sha256=R1L9kA6rhZxftw6iq7p4FwswcrJvU8HRn0XOkv6bRJA,4852
+snowpark_checkpoints_configuration-0.3.0.dist-info/METADATA,sha256=Bjd-RHBmSKluYnJGbrsNEggmPwgJacvGGhBESZHT1i4,2782
+snowpark_checkpoints_configuration-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+snowpark_checkpoints_configuration-0.3.0.dist-info/licenses/LICENSE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+snowpark_checkpoints_configuration-0.3.0.dist-info/RECORD,,

{snowpark_checkpoints_configuration-0.2.0rc1.dist-info → snowpark_checkpoints_configuration-0.3.0.dist-info}/licenses/LICENSE

@@ -175,28 +175,3 @@
       of your accepting any such warranty or additional liability.
 
    END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2025 Snowflake
-
-   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.

snowpark_checkpoints_configuration-0.2.0rc1.dist-info/METADATA

@@ -1,267 +0,0 @@
-Metadata-Version: 2.4
-Name: snowpark-checkpoints-configuration
-Version: 0.2.0rc1
-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/
-Author: Snowflake Inc.
-License: 
-                                         Apache License
-                                   Version 2.0, January 2004
-                                http://www.apache.org/licenses/
-        
-           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-        
-           1. Definitions.
-        
-              "License" shall mean the terms and conditions for use, reproduction,
-              and distribution as defined by Sections 1 through 9 of this document.
-        
-              "Licensor" shall mean the copyright owner or entity authorized by
-              the copyright owner that is granting the License.
-        
-              "Legal Entity" shall mean the union of the acting entity and all
-              other entities that control, are controlled by, or are under common
-              control with that entity. For the purposes of this definition,
-              "control" means (i) the power, direct or indirect, to cause the
-              direction or management of such entity, whether by contract or
-              otherwise, or (ii) ownership of fifty percent (50%) or more of the
-              outstanding shares, or (iii) beneficial ownership of such entity.
-        
-              "You" (or "Your") shall mean an individual or Legal Entity
-              exercising permissions granted by this License.
-        
-              "Source" form shall mean the preferred form for making modifications,
-              including but not limited to software source code, documentation
-              source, and configuration files.
-        
-              "Object" form shall mean any form resulting from mechanical
-              transformation or translation of a Source form, including but
-              not limited to compiled object code, generated documentation,
-              and conversions to other media types.
-        
-              "Work" shall mean the work of authorship, whether in Source or
-              Object form, made available under the License, as indicated by a
-              copyright notice that is included in or attached to the work
-              (an example is provided in the Appendix below).
-        
-              "Derivative Works" shall mean any work, whether in Source or Object
-              form, that is based on (or derived from) the Work and for which the
-              editorial revisions, annotations, elaborations, or other modifications
-              represent, as a whole, an original work of authorship. For the purposes
-              of this License, Derivative Works shall not include works that remain
-              separable from, or merely link (or bind by name) to the interfaces of,
-              the Work and Derivative Works thereof.
-        
-              "Contribution" shall mean any work of authorship, including
-              the original version of the Work and any modifications or additions
-              to that Work or Derivative Works thereof, that is intentionally
-              submitted to Licensor for inclusion in the Work by the copyright owner
-              or by an individual or Legal Entity authorized to submit on behalf of
-              the copyright owner. For the purposes of this definition, "submitted"
-              means any form of electronic, verbal, or written communication sent
-              to the Licensor or its representatives, including but not limited to
-              communication on electronic mailing lists, source code control systems,
-              and issue tracking systems that are managed by, or on behalf of, the
-              Licensor for the purpose of discussing and improving the Work, but
-              excluding communication that is conspicuously marked or otherwise
-              designated in writing by the copyright owner as "Not a Contribution."
-        
-              "Contributor" shall mean Licensor and any individual or Legal Entity
-              on behalf of whom a Contribution has been received by Licensor and
-              subsequently incorporated within the Work.
-        
-           2. Grant of Copyright License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              copyright license to reproduce, prepare Derivative Works of,
-              publicly display, publicly perform, sublicense, and distribute the
-              Work and such Derivative Works in Source or Object form.
-        
-           3. Grant of Patent License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              (except as stated in this section) patent license to make, have made,
-              use, offer to sell, sell, import, and otherwise transfer the Work,
-              where such license applies only to those patent claims licensable
-              by such Contributor that are necessarily infringed by their
-              Contribution(s) alone or by combination of their Contribution(s)
-              with the Work to which such Contribution(s) was submitted. If You
-              institute patent litigation against any entity (including a
-              cross-claim or counterclaim in a lawsuit) alleging that the Work
-              or a Contribution incorporated within the Work constitutes direct
-              or contributory patent infringement, then any patent licenses
-              granted to You under this License for that Work shall terminate
-              as of the date such litigation is filed.
-        
-           4. Redistribution. You may reproduce and distribute copies of the
-              Work or Derivative Works thereof in any medium, with or without
-              modifications, and in Source or Object form, provided that You
-              meet the following conditions:
-        
-              (a) You must give any other recipients of the Work or
-                  Derivative Works a copy of this License; and
-        
-              (b) You must cause any modified files to carry prominent notices
-                  stating that You changed the files; and
-        
-              (c) You must retain, in the Source form of any Derivative Works
-                  that You distribute, all copyright, patent, trademark, and
-                  attribution notices from the Source form of the Work,
-                  excluding those notices that do not pertain to any part of
-                  the Derivative Works; and
-        
-              (d) If the Work includes a "NOTICE" text file as part of its
-                  distribution, then any Derivative Works that You distribute must
-                  include a readable copy of the attribution notices contained
-                  within such NOTICE file, excluding those notices that do not
-                  pertain to any part of the Derivative Works, in at least one
-                  of the following places: within a NOTICE text file distributed
-                  as part of the Derivative Works; within the Source form or
-                  documentation, if provided along with the Derivative Works; or,
-                  within a display generated by the Derivative Works, if and
-                  wherever such third-party notices normally appear. The contents
-                  of the NOTICE file are for informational purposes only and
-                  do not modify the License. You may add Your own attribution
-                  notices within Derivative Works that You distribute, alongside
-                  or as an addendum to the NOTICE text from the Work, provided
-                  that such additional attribution notices cannot be construed
-                  as modifying the License.
-        
-              You may add Your own copyright statement to Your modifications and
-              may provide additional or different license terms and conditions
-              for use, reproduction, or distribution of Your modifications, or
-              for any such Derivative Works as a whole, provided Your use,
-              reproduction, and distribution of the Work otherwise complies with
-              the conditions stated in this License.
-        
-           5. Submission of Contributions. Unless You explicitly state otherwise,
-              any Contribution intentionally submitted for inclusion in the Work
-              by You to the Licensor shall be under the terms and conditions of
-              this License, without any additional terms or conditions.
-              Notwithstanding the above, nothing herein shall supersede or modify
-              the terms of any separate license agreement you may have executed
-              with Licensor regarding such Contributions.
-        
-           6. Trademarks. This License does not grant permission to use the trade
-              names, trademarks, service marks, or product names of the Licensor,
-              except as required for reasonable and customary use in describing the
-              origin of the Work and reproducing the content of the NOTICE file.
-        
-           7. Disclaimer of Warranty. Unless required by applicable law or
-              agreed to in writing, Licensor provides the Work (and each
-              Contributor provides its Contributions) on an "AS IS" BASIS,
-              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-              implied, including, without limitation, any warranties or conditions
-              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-              PARTICULAR PURPOSE. You are solely responsible for determining the
-              appropriateness of using or redistributing the Work and assume any
-              risks associated with Your exercise of permissions under this License.
-        
-           8. Limitation of Liability. In no event and under no legal theory,
-              whether in tort (including negligence), contract, or otherwise,
-              unless required by applicable law (such as deliberate and grossly
-              negligent acts) or agreed to in writing, shall any Contributor be
-              liable to You for damages, including any direct, indirect, special,
-              incidental, or consequential damages of any character arising as a
-              result of this License or out of the use or inability to use the
-              Work (including but not limited to damages for loss of goodwill,
-              work stoppage, computer failure or malfunction, or any and all
-              other commercial damages or losses), even if such Contributor
-              has been advised of the possibility of such damages.
-        
-           9. Accepting Warranty or Additional Liability. While redistributing
-              the Work or Derivative Works thereof, You may choose to offer,
-              and charge a fee for, acceptance of support, warranty, indemnity,
-              or other liability obligations and/or rights consistent with this
-              License. However, in accepting such obligations, You may act only
-              on Your own behalf and on Your sole responsibility, not on behalf
-              of any other Contributor, and only if You agree to indemnify,
-              defend, and hold each Contributor harmless for any liability
-              incurred by, or claims asserted against, such Contributor by reason
-              of your accepting any such warranty or additional liability.
-        
-           END OF TERMS AND CONDITIONS
-        
-           APPENDIX: How to apply the Apache License to your work.
-        
-              To apply the Apache License to your work, attach the following
-              boilerplate notice, with the fields enclosed by brackets "[]"
-              replaced with your own identifying information. (Don't include
-              the brackets!)  The text should be enclosed in the appropriate
-              comment syntax for the file format. We also recommend that a
-              file or class name and description of purpose be included on the
-              same "printed page" as the copyright notice for easier
-              identification within third-party archives.
-        
-           Copyright 2025 Snowflake
-        
-           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.
-License-File: LICENSE
-Keywords: Snowflake,Snowpark,analytics,cloud,database,db
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Environment :: Other Environment
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: Intended Audience :: Information Technology
-Classifier: Intended Audience :: System Administrators
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: SQL
-Classifier: Topic :: Database
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Topic :: Software Development
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
-Requires-Dist: pydantic>=1.8.2
-Requires-Dist: snowflake-snowpark-python
-Provides-Extra: development
-Requires-Dist: coverage>=7.6.7; extra == 'development'
-Requires-Dist: hatchling==1.25.0; extra == 'development'
-Requires-Dist: pre-commit>=4.0.1; extra == 'development'
-Requires-Dist: pyarrow>=18.0.0; extra == 'development'
-Requires-Dist: pytest-cov>=6.0.0; extra == 'development'
-Requires-Dist: pytest>=8.3.3; extra == 'development'
-Requires-Dist: setuptools>=70.0.0; extra == 'development'
-Requires-Dist: twine==5.1.1; extra == 'development'
-Description-Content-Type: text/markdown
-
-# snowpark-checkpoints-configuration
-
----
-**NOTE**
-
-This package is on Private Preview.
-
----
-
-**snowpark-checkpoints-configuration** is a module for loading `checkpoint.json` and provides a model. 
-This module will work automatically with *snowpark-checkpoints-collector*  and *snowpark-checkpoints-validators*. This will try to read the configuration file from the current working directory.
-
-## Usage
-
-To explicit load a file, you can import  `CheckpointMetadata` and create an instance as shown below:
-
-```python
-from snowflake.snowpark_checkpoints_configuration import CheckpointMetadata
-
-my_checkpoint_metadata = CheckpointMetadata("path/to/checkpoint.json")
-
-checkpoint_model = my_checkpoint_metadata.get("my_checkpoint_name")
-...
-```
-------

snowpark_checkpoints_configuration-0.2.0rc1.dist-info/RECORD

@@ -1,4 +0,0 @@
-snowpark_checkpoints_configuration-0.2.0rc1.dist-info/METADATA,sha256=VWGHNDbGiJWd6SydDmdh5v0_FnF7Ym6f6D6y66_0bbE,15574
-snowpark_checkpoints_configuration-0.2.0rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-snowpark_checkpoints_configuration-0.2.0rc1.dist-info/licenses/LICENSE,sha256=pmjhbh6uVhV5MBXOlou_UZgFP7CYVQITkCCdvfcS5lY,11340
-snowpark_checkpoints_configuration-0.2.0rc1.dist-info/RECORD,,