fix: pass config and backend explicitly to Connection constructor

Connection.__init__ now accepts `backend` and `config_override` kwargs
instead of reading from the module-level global config. This ensures
Instance creates connections using its own config, not the global one.

Also removes set_thread_safe() — thread-safe mode is an infrastructure
decision set via DJ_THREAD_SAFE env var, not a runtime toggle.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dimitri-yatsenko

src/datajoint/__init__.py

@@ -160,8 +160,7 @@ def conn(
                 "Database password not configured. Set dj.config['database.password'] or pass password= argument."
             )
 
-        instance_module._singleton_connection = Connection(host, user, password, port, use_tls)
-        instance_module._singleton_connection._config = _global_config
+        instance_module._singleton_connection = Connection(host, user, password, port, use_tls, config_override=_global_config)
 
     return _get_singleton_connection()
 

src/datajoint/connection.py

@@ -11,12 +11,16 @@
 import re
 import warnings
 from contextlib import contextmanager
+from typing import TYPE_CHECKING
 
 from . import errors
 from .adapters import get_adapter
 from .blob import pack, unpack
 from .dependencies import Dependencies
 from .settings import config
+
+if TYPE_CHECKING:
+    from .settings import Config
 from .version import __version__
 
 logger = logging.getLogger(__name__.split(".")[0])
@@ -163,13 +167,19 @@ def __init__(
         password: str,
         port: int | None = None,
         use_tls: bool | dict | None = None,
+        *,
+        backend: str | None = None,
+        config_override: "Config | None" = None,
     ) -> None:
+        # Config reference — use override if provided, else global config
+        self._config = config_override if config_override is not None else config
+
         if ":" in host:
             # the port in the hostname overrides the port argument
             host, port = host.split(":")
             port = int(port)
         elif port is None:
-            port = config["database.port"]
+            port = self._config["database.port"]
         self.conn_info = dict(host=host, port=port, user=user, passwd=password)
         if use_tls is not False:
             # use_tls can be: None (auto-detect), True (enable), False (disable), or dict (custom config)
@@ -186,11 +196,9 @@ def __init__(
         self._query_cache = None
         self._is_closed = True  # Mark as closed until connect() succeeds
 
-        # Config reference - defaults to global config, but Instance sets its own
-        self._config = config
-
-        # Select adapter based on configured backend
-        backend = self._config["database.backend"]
+        # Select adapter: explicit backend > config backend
+        if backend is None:
+            backend = self._config["database.backend"]
         self.adapter = get_adapter(backend)
 
         self.connect()

src/datajoint/instance.py

@@ -21,21 +21,19 @@
 
 def _load_thread_safe() -> bool:
     """
-    Load thread_safe setting from environment or config file.
+    Check if thread-safe mode is enabled.
+
+    Thread-safe mode is controlled by the ``DJ_THREAD_SAFE`` environment
+    variable, which must be set before the process starts.
 
     Returns
     -------
     bool
         True if thread-safe mode is enabled.
     """
-    # Check environment variable first
     env_val = os.environ.get("DJ_THREAD_SAFE", "").lower()
     if env_val in ("true", "1", "yes"):
         return True
-    if env_val in ("false", "0", "no"):
-        return False
-
-    # Default: thread-safe mode is off
     return False
 
 
@@ -104,11 +102,16 @@ def __init__(
         if port is None:
             port = self.config.database.port
 
-        # Create connection
-        self.connection = Connection(host, user, password, port, use_tls)
-
-        # Attach config to connection so tables can access it
-        self.connection._config = self.config
+        # Create connection with this instance's config and backend
+        self.connection = Connection(
+            host,
+            user,
+            password,
+            port,
+            use_tls,
+            backend=self.config.database.backend,
+            config_override=self.config,
+        )
 
     def Schema(
         self,
@@ -235,9 +238,7 @@ def _get_singleton_connection() -> Connection:
                 "Database password not configured. Set dj.config['database.password'] or DJ_PASS environment variable."
             )
 
-        _singleton_connection = Connection(host, user, password, port, use_tls)
-        # Attach global config to connection
-        _singleton_connection._config = _global_config
+        _singleton_connection = Connection(host, user, password, port, use_tls, config_override=_global_config)
 
     return _singleton_connection