mssql-python 1.0.0__cp314-cp314-win_amd64.whl

mssql_python/db_connection.py

@@ -0,0 +1,53 @@
+"""
+Copyright (c) Microsoft Corporation.
+Licensed under the MIT license.
+This module provides a way to create a new connection object to interact with the database.
+"""
+
+from typing import Any, Dict, Optional, Union
+
+from mssql_python.connection import Connection
+
+
+def connect(
+    connection_str: str = "",
+    autocommit: bool = False,
+    attrs_before: Optional[Dict[int, Union[int, str, bytes]]] = None,
+    timeout: int = 0,
+    **kwargs: Any
+) -> Connection:
+    """
+    Constructor for creating a connection to the database.
+
+    Args:
+        connection_str (str): The connection string to connect to.
+        autocommit (bool): If True, causes a commit to be performed after each SQL statement.
+    TODO: Add the following parameters to the function signature:
+        timeout (int): The timeout for the connection attempt, in seconds.
+        readonly (bool): If True, the connection is set to read-only.
+        attrs_before (dict): A dictionary of connection attributes to set before connecting.
+    Keyword Args:
+        **kwargs: Additional key/value pairs for the connection string.
+    Below attributes are not implemented in the internal driver:
+    - encoding (str): The encoding for the connection string.
+    - ansi (bool): If True, indicates the driver does not support Unicode.
+
+    Returns:
+        Connection: A new connection object to interact with the database.
+
+    Raises:
+        DatabaseError: If there is an error while trying to connect to the database.
+        InterfaceError: If there is an error related to the database interface.
+
+    This function provides a way to create a new connection object, which can then
+    be used to perform database operations such as executing queries, committing
+    transactions, and closing the connection.
+    """
+    conn = Connection(
+        connection_str,
+        autocommit=autocommit,
+        attrs_before=attrs_before,
+        timeout=timeout,
+        **kwargs
+    )
+    return conn

mssql_python/ddbc_bindings.py

@@ -0,0 +1,137 @@
+"""
+Dynamic loading of platform-specific DDBC bindings for mssql-python.
+
+This module handles the runtime loading of the appropriate compiled extension
+module based on the current platform, architecture, and Python version.
+"""
+
+import os
+import importlib.util
+import sys
+import platform
+
+def normalize_architecture(platform_name_param, architecture_param):
+    """
+    Normalize architecture names for the given platform.
+
+    Args:
+        platform_name_param (str): Platform name ('windows', 'darwin', 'linux')
+        architecture_param (str): Architecture string to normalize
+
+    Returns:
+        str: Normalized architecture name
+
+    Raises:
+        ImportError: If architecture is not supported for the given platform
+        OSError: If platform is not supported
+    """
+    arch_lower = architecture_param.lower()
+
+    if platform_name_param == "windows":
+        arch_map = {
+            "win64": "x64",
+            "amd64": "x64",
+            "x64": "x64",
+            "win32": "x86",
+            "x86": "x86",
+            "arm64": "arm64",
+        }
+        if arch_lower in arch_map:
+            return arch_map[arch_lower]
+        supported = list(set(arch_map.keys()))
+        raise ImportError(
+            f"Unsupported architecture '{architecture_param}' for platform "
+            f"'{platform_name_param}'; expected one of {supported}"
+        )
+
+    if platform_name_param == "darwin":
+        # For macOS, return runtime architecture
+        return platform.machine().lower()
+
+    if platform_name_param == "linux":
+        arch_map = {
+            "x64": "x86_64",
+            "amd64": "x86_64",
+            "x86_64": "x86_64",
+            "arm64": "arm64",
+            "aarch64": "arm64",
+        }
+        if arch_lower in arch_map:
+            return arch_map[arch_lower]
+        supported = list(set(arch_map.keys()))
+        raise ImportError(
+            f"Unsupported architecture '{architecture_param}' for platform "
+            f"'{platform_name_param}'; expected one of {supported}"
+        )
+
+    supported_platforms_list = ["windows", "darwin", "linux"]
+    raise OSError(
+        f"Unsupported platform '{platform_name_param}'; expected one of "
+        f"{supported_platforms_list}"
+    )
+
+
+# Get current Python version and architecture
+python_version = f"cp{sys.version_info.major}{sys.version_info.minor}"
+
+platform_name = platform.system().lower()
+raw_architecture = platform.machine().lower()
+
+# Special handling for macOS universal2 binaries
+if platform_name == "darwin":
+    architecture = "universal2"
+else:
+    architecture = normalize_architecture(platform_name, raw_architecture)
+
+    # Handle Windows-specific naming for binary files
+    if platform_name == "windows" and architecture == "x64":
+        architecture = "amd64"
+
+# Validate supported platforms
+if platform_name not in ["windows", "darwin", "linux"]:
+    supported_platforms = ["windows", "darwin", "linux"]
+    raise ImportError(
+        f"Unsupported platform '{platform_name}' for mssql-python; expected one "
+        f"of {supported_platforms}"
+    )
+
+# Determine extension based on platform
+if platform_name == "windows":
+    extension = ".pyd"
+else:  # macOS or Linux
+    extension = ".so"
+
+# Find the specifically matching module file
+module_dir = os.path.dirname(__file__)
+expected_module = f"ddbc_bindings.{python_version}-{architecture}{extension}"
+module_path = os.path.join(module_dir, expected_module)
+
+if not os.path.exists(module_path):
+    # Fallback to searching for any matching module if the specific one isn't found
+    module_files = [
+        f
+        for f in os.listdir(module_dir)
+        if f.startswith("ddbc_bindings.") and f.endswith(extension)
+    ]
+    if not module_files:
+        raise ImportError(
+            f"No ddbc_bindings module found for {python_version}-{architecture} "
+            f"with extension {extension}"
+        )
+    module_path = os.path.join(module_dir, module_files[0])
+    print(
+        f"Warning: Using fallback module file {module_files[0]} instead of "
+        f"{expected_module}"
+    )
+
+# Use the original module name 'ddbc_bindings' that the C extension was compiled with
+module_name = "ddbc_bindings"
+spec = importlib.util.spec_from_file_location(module_name, module_path)
+module = importlib.util.module_from_spec(spec)
+sys.modules[module_name] = module
+spec.loader.exec_module(module)
+
+# Copy all attributes from the loaded module to this module
+for attr in dir(module):
+    if not attr.startswith("__"):
+        globals()[attr] = getattr(module, attr)