snowflake-connector-python 5.0.0__cp312-cp312-win_arm64.whl

snowflake/connector/_internal/_private_key_helper.py

@@ -0,0 +1,50 @@
+"""Helper functions for private key conversion."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..errors import ProgrammingError
+
+
+def normalize_private_key(private_key: Any) -> bytes | str:
+    """
+    Normalize private_key to a format that can be sent to the Rust core.
+
+    The Rust core handles:
+    - bytes: DER format (sent via connection_set_option_bytes)
+    - str: base64-encoded PEM or DER (sent via connection_set_option_string)
+
+    This function only converts RSAPrivateKey objects to bytes.
+    bytes and str are passed through as-is.
+
+    Args:
+        private_key: Private key in one of the supported formats:
+                     - bytes (DER format)
+                     - str (base64-encoded PEM or DER)
+                     - RSAPrivateKey object
+
+    Returns:
+        bytes or str: Private key ready to be sent to Rust core
+
+    Raises:
+        ProgrammingError: If the private_key type is not supported or conversion fails
+    """
+    if isinstance(private_key, (bytes, str)):
+        # Pass through - Rust handles DER bytes and base64-encoded strings (PEM or DER)
+        return private_key
+
+    # Handle RSAPrivateKey object from cryptography library
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
+
+    if isinstance(private_key, RSAPrivateKey):
+        return private_key.private_bytes(
+            encoding=serialization.Encoding.DER,
+            format=serialization.PrivateFormat.PKCS8,
+            encryption_algorithm=serialization.NoEncryption(),
+        )
+    raise ProgrammingError(
+        f"Unsupported private_key type: {type(private_key)}. "
+        "Expected bytes, str (base64-encoded), or RSAPrivateKey object."
+    )

snowflake/connector/_internal/api_client/__init__.py

@@ -0,0 +1,93 @@
+"""Initialize the core API with the default logger callback."""
+
+import logging
+
+from snowflake.connector.errors import OperationalError
+
+from ..logging import _get_connector_stdlib_logger, _get_sf_core_stdlib_logger
+from ..logging.config import LoggingConfiguration
+
+
+try:
+    from snowflake.connector._core import sf_core_python
+except ImportError as err:
+    raise OperationalError(
+        msg=(
+            "Couldn't load the native library (sf_core_python). "
+            "Ensure the package was installed from a pre-built wheel or built locally."
+        )
+    ) from err
+
+
+def _sf_core_level_to_python(level: int) -> int | None:
+    """Map sf_core wire level to stdlib logging level.
+
+    DEBUG is the finest level Python supports. Core's ``normalize_event`` collapses
+    finer levels (Rust ``tracing::trace!``, legacy TRACE) to wire level 3 before
+    the callback, so level 4 should not normally reach this path. The ``>= 3``
+    branch is defensive: any wire level 3 or higher is delivered as DEBUG rather
+    than dropped.
+    """
+    if level >= 3:
+        return logging.DEBUG
+    match level:
+        case 0:
+            return logging.ERROR
+        case 1:
+            return logging.WARNING
+        case 2:
+            return logging.INFO
+        case _:
+            return None
+
+
+def _logger_callback(
+    level: int,
+    message: str,
+    filename: str,
+    line: int,
+    function: str,
+    logger_name: str,
+) -> int:
+    py_level = _sf_core_level_to_python(level)
+    if py_level is None:
+        return 0
+
+    target_logger = logging.getLogger(logger_name) if logger_name else _get_sf_core_stdlib_logger()
+
+    if not target_logger.isEnabledFor(py_level):
+        return 0
+
+    record = target_logger.makeRecord(
+        target_logger.name,
+        py_level,
+        filename,
+        line,
+        message,
+        (),
+        None,
+        func=function,
+    )
+    target_logger.handle(record)
+    return 0
+
+
+def register_default_logger_callback() -> None:
+    """Register the default logger callback with the core API."""
+    status, troubleshooting_enabled = sf_core_python.init(_logger_callback)
+    if status != 0:
+        raise OperationalError(
+            msg=(
+                f"sf_core_python.init failed (status={status}). "
+                "Ensure the package was installed from a pre-built wheel or built locally."
+            )
+        )
+    LoggingConfiguration.initialize(troubleshooting_enabled=troubleshooting_enabled)
+
+
+register_default_logger_callback()
+
+from snowflake.connector.version import __version__  # noqa: E402
+
+
+_get_connector_stdlib_logger().info("Python connector starting v%s", __version__)

snowflake/connector/_internal/api_client/bridge.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from snowflake.connector.errors import OperationalError
+
+from ..protobuf_gen.proto_exception import ProtoTransportException
+
+
+try:
+    from snowflake.connector._core import sf_core_python
+except ImportError as err:
+    raise OperationalError(
+        msg=(
+            "Couldn't load the native library (sf_core_python). "
+            "Ensure the package was installed from a pre-built wheel or built locally."
+        )
+    ) from err
+
+
+class ProtoTransport:
+    """Bridge between Python proto RPC calls and the Rust core via PyO3.
+
+    :meth:`handle_message_async` — returns a native awaitable from Rust. The
+        request runs as a tokio task; dropping the awaitable (which is what
+        cancelling the surrounding asyncio task does) cancels the operation's
+        token in core.
+
+    :meth:`handle_message` — blocking call (releases the GIL).
+    """
+
+    async def handle_message_async(self, api: str, method: str, message: bytes) -> tuple[int, bytes]:
+        result: tuple[int, bytes] = await sf_core_python.call_proto_async(api, method, message)  # type: ignore[assignment]
+        status, response_bytes = result
+        if status in (0, 1, 2):
+            return status, response_bytes
+        raise ProtoTransportException(f"Unknown error code: {status}")
+
+    def handle_message(self, api: str, method: str, message: bytes) -> tuple[int, bytes]:
+        status, response_bytes = sf_core_python.call_proto(api, method, message)
+        if status in (0, 1, 2):
+            return status, response_bytes
+        raise ProtoTransportException(f"Unknown error code: {status}")