NO-SNOW: Add core library import

Author: sfc-gh-turbaszek

pyproject.toml

@@ -23,3 +23,6 @@ repair-wheel-command = ""
 
 [tool.cibuildwheel.windows]
 archs = ["AMD64"]
+
+[tool.check-manifest]
+ignore = ["src/snowflake/connector/minicore/*"]

setup.cfg

@@ -72,6 +72,12 @@ where = src
 exclude = snowflake.connector.cpp*
 include = snowflake.*
 
+[options.package_data]
+snowflake.connector.minicore =
+    *.so
+    *.dll
+    *.dylib
+
 [options.entry_points]
 console_scripts =
     snowflake-dump-ocsp-response = snowflake.connector.tool.dump_ocsp_response:main

src/snowflake/connector/__init__.py

@@ -5,6 +5,8 @@
 
 from functools import wraps
 
+from ._utils import core_loader
+
 apilevel = "2.0"
 threadsafety = 2
 paramstyle = "pyformat"
@@ -48,6 +50,14 @@
 logging.getLogger(__name__).addHandler(NullHandler())
 setup_external_libraries()
 
+# Load the core library - failures are captured in core_loader and don't prevent module loading
+try:
+    core_loader.load()
+except Exception:
+    # Silently continue if core loading fails - the error is already captured in core_loader
+    # This ensures the connector module loads even if the minicore library is unavailable
+    pass
+
 
 @wraps(SnowflakeConnection.__init__)
 def Connect(**kwargs) -> SnowflakeConnection:

src/snowflake/connector/_utils.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+import ctypes
+import importlib
 import string
+import sys
 from enum import Enum
 from inspect import stack
 from random import choice
@@ -96,3 +99,55 @@ def get_application_path() -> str:
         return outermost_frame.filename
     except Exception:
         return "unknown"
+
+
+class _CoreLoader:
+    def __init__(self):
+        self._version: bytes | None = None
+        self._error: Exception | None = None
+
+    @staticmethod
+    def _get_core_path():
+        # Define the file name for each platform
+        if sys.platform.startswith("win"):
+            lib_name = "libsf_mini_core.dll"
+        elif sys.platform.startswith("darwin"):
+            lib_name = "libsf_mini_core.dyldib"
+        else:
+            lib_name = "libsf_mini_core.so"
+
+        files = importlib.resources.files("snowflake.connector.minicore")
+        return files.joinpath(lib_name)
+
+    @staticmethod
+    def _register_functions(core: ctypes.CDLL):
+        core.sf_core_full_version.argtypes = []
+        core.sf_core_full_version.restype = ctypes.c_char_p
+
+    @staticmethod
+    def _load_minicore(path: str) -> ctypes.CDLL:
+        # This context manager is the safe way to get a
+        # file path from importlib.resources. It handles cases
+        # where the file is inside a zip and needs to be extracted
+        # to a temporary location.
+        with importlib.resources.as_file(path) as lib_path:
+            core = ctypes.CDLL(str(lib_path))
+        return core
+
+    def load(self) -> None:
+        try:
+            path = self._get_core_path()
+            core = self._load_minicore(path)
+            self._register_functions(core)
+            self._version = core.sf_core_full_version()
+        except Exception as err:
+            self._error = err
+
+    def get_load_error(self) -> str:
+        return str(self._error)
+
+    def get_core_version(self) -> str:
+        return self._version.decode("utf-8") if self._version else self._version
+
+
+core_loader = _CoreLoader()

src/snowflake/connector/auth/_auth.py

@@ -17,7 +17,7 @@
     load_pem_private_key,
 )
 
-from .._utils import get_application_path
+from .._utils import core_loader, get_application_path
 from ..compat import urlencode
 from ..constants import (
     DAY_IN_SECONDS,
@@ -144,6 +144,8 @@ def base_auth_data(
                         platform_detection_timeout_seconds=platform_detection_timeout_seconds,
                         session_manager=session_manager.clone(max_retries=0),
                     ),
+                    "CORE_LOAD_ERROR": core_loader.get_load_error(),
+                    "CORE_VERSION": core_loader.get_core_version(),
                 },
             },
         }