sqlspec 0.8.0__tar.gz → 0.9.1__tar.gz

{sqlspec-0.8.0 → sqlspec-0.9.1}/Makefile

@@ -118,7 +118,7 @@ clean:                                              ## Cleanup temporary build a
 .PHONY: test
 test:                                               ## Run the tests
 	@echo "${INFO} Running test cases... 🧪"
-	@uv run pytest tests
+	@uv run pytest -n 2 --dist=loadgroup tests
 	@echo "${OK} Tests complete ✨"
 
 .PHONY: test-all
@@ -128,7 +128,7 @@ test-all: tests				                        ## Run all tests
 .PHONY: coverage
 coverage:                                           ## Run tests with coverage report
 	@echo "${INFO} Running tests with coverage... 📊"
-	@uv run pytest --cov -n auto --quiet
+	@uv run pytest --cov -n 2 --dist=loadgroup --quiet
 	@uv run coverage html >/dev/null 2>&1
 	@uv run coverage xml >/dev/null 2>&1
 	@echo "${OK} Coverage report generated ✨"

{sqlspec-0.8.0 → sqlspec-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.8.0
+Version: 0.9.1
 Summary: SQL Experiments in Python
 Author-email: Cody Fincher <cody@litestar.dev>
 Maintainer-email: Litestar Developers <hello@litestar.dev>
@@ -42,6 +42,8 @@ Provides-Extra: orjson
 Requires-Dist: orjson; extra == 'orjson'
 Provides-Extra: performance
 Requires-Dist: sqlglot[rs]; extra == 'performance'
+Provides-Extra: psqlpy
+Requires-Dist: psqlpy; extra == 'psqlpy'
 Provides-Extra: psycopg
 Requires-Dist: psycopg[binary,pool]; extra == 'psycopg'
 Provides-Extra: pydantic
@@ -81,6 +83,145 @@ SQLSpec is an experimental Python library designed to streamline and modernize y
 
 SQLSpec is a work in progress. While it offers a solid foundation for modern SQL interactions, it does not yet include every feature you might find in a mature ORM or database toolkit. The focus is on building a robust, flexible core that can be extended over time.
 
+## Examples
+
+We've talked about what SQLSpec is not, so let's look at what it can do.
+
+These are just a few of the examples that demonstrate SQLSpec's flexibility and each of the bundled adapters offer the same config and driver interfaces.
+
+### DuckDB LLM
+
+This is a quick implementation using some of the built in Secret and Extension management features of SQLSpec's DuckDB integration.
+
+It allows you to communicate with any compatible OpenAPI conversations endpoint (such as Ollama).  This examples:
+
+- auto installs the `open_prompt` DuckDB extensions
+- automatically creates the correct `open_prompt` comptaible secret required to use the extension
+
+```py
+# /// script
+# dependencies = [
+#   "sqlspec[duckdb,performance]",
+# ]
+# ///
+import os
+
+from sqlspec import SQLSpec
+from sqlspec.adapters.duckdb import DuckDBConfig
+from pydantic import BaseModel
+
+class ChatMessage(BaseModel):
+    message: str
+
+sql = SQLSpec()
+etl_config = sql.add_config(
+    DuckDBConfig(
+        extensions=[{"name": "open_prompt"}],
+        secrets=[
+            {
+                "secret_type": "open_prompt",
+                "name": "open_prompt",
+                "value": {
+                    "api_url": "http://127.0.0.1:11434/v1/chat/completions",
+                    "model_name": "gemma3:1b",
+                    "api_timeout": "120",
+                },
+            }
+        ],
+    )
+)
+with sql.provide_session(etl_config) as session:
+    result = session.select_one("SELECT open_prompt(?)", data.message, schema_type=ChatMessage)
+    print(result) # result is a ChatMessage pydantic model
+```
+
+### DuckDB Gemini Embeddings
+
+In this example, we are again using DuckDB.  However, we are going to use the built in to call the Google Gemini embeddings service directly from the database.
+
+This example will
+
+- auto installs the `http_client` and `vss` (vector similarity search) DuckDB extensions
+- when a connection is created, it ensures that the `generate_embeddings` macro exists in the DuckDB database.
+- Execute a simple query to call the Google API
+
+```py
+# /// script
+# dependencies = [
+#   "sqlspec[duckdb,performance]",
+# ]
+# ///
+import os
+
+from sqlspec import SQLSpec
+from sqlspec.adapters.duckdb import DuckDBConfig
+
+EMBEDDING_MODEL = "gemini-embedding-exp-03-07"
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+API_URL = (
+    f"https://generativelanguage.googleapis.com/v1beta/models/{EMBEDDING_MODEL}:embedContent?key=${GOOGLE_API_KEY}"
+)
+
+sql = SQLSpec()
+etl_config = sql.add_config(
+    DuckDBConfig(
+        extensions=[{"name": "vss"}, {"name": "http_client"}],
+        on_connection_create=lambda connection: connection.execute(f"""
+            CREATE IF NOT EXISTS MACRO generate_embedding(q) AS (
+                WITH  __request AS (
+                    SELECT http_post(
+                        '{API_URL}',
+                        headers => MAP {{
+                            'accept': 'application/json',
+                        }},
+                        params => MAP {{
+                            'model': 'models/{EMBEDDING_MODEL}',
+                            'parts': [{{ 'text': q }}],
+                            'taskType': 'SEMANTIC_SIMILARITY'
+                        }}
+                    ) AS response
+                )
+                SELECT *
+                FROM __request,
+            );
+        """),
+    )
+)
+with sql.provide_session(etl_config) as session:
+    result = session.select_one("SELECT generate_embedding('example text')")
+    print(result) # result is a dictionary when `schema_type` is omitted.
+```
+
+### Basic Litestar Integration
+
+In this example we are going to demonstrate how to create a basic configuration that integrates into Litestar.
+
+```py
+# /// script
+# dependencies = [
+#   "sqlspec[aiosqlite]",
+#   "litestar[standard]",
+# ]
+# ///
+
+from aiosqlite import Connection
+from litestar import Litestar, get
+
+from sqlspec.adapters.aiosqlite import AiosqliteConfig, AiosqliteDriver
+from sqlspec.extensions.litestar import SQLSpec
+
+
+@get("/")
+async def simple_sqlite(db_session: AiosqliteDriver) -> dict[str, str]:
+    return await db_session.select_one("SELECT 'Hello, world!' AS greeting")
+
+
+sqlspec = SQLSpec(config=DatabaseConfig(
+    config=[AiosqliteConfig(), commit_mode="autocommit")],
+)
+app = Litestar(route_handlers=[simple_sqlite], plugins=[sqlspec])
+```
+
 ## Inspiration and Future Direction
 
 SQLSpec originally drew inspiration from features found in the `aiosql` library.  This is a great library for working with and executed SQL stored in files.  It's unclear how much of an overlap there will be between the two libraries, but it's possible that some features will be contributed back to `aiosql` where appropriate.
@@ -102,6 +243,7 @@ This list is not final. If you have a driver you'd like to see added, please ope
 | [`asyncpg`](https://magicstack.github.io/asyncpg/current/)                                                    | PostgreSQL | Async   | ✅         |
 | [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Sync    | ✅         |
 | [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Async   | ✅         |
+| [`psqlpy`](https://psqlpy-python.github.io/)                                                                  | PostgreSQL | Async   | ✅        |
 | [`aiosqlite`](https://github.com/omnilib/aiosqlite)                                                           | SQLite     | Async   | ✅         |
 | `sqlite3`                                                                                                    | SQLite     | Sync    | ✅         |
 | [`oracledb`](https://oracle.github.io/python-oracledb/)                                                      | Oracle     | Async   | ✅         |
@@ -118,7 +260,7 @@ This list is not final. If you have a driver you'd like to see added, please ope
 - `sqlspec/`:
     - `adapters/`: Contains all database drivers and associated configuration.
     - `extensions/`:
-        - `litestar/`: Future home of `litestar` integration.
+        - `litestar/`: Litestar framework integration ✅
         - `fastapi/`: Future home of `fastapi` integration.
         - `flask/`: Future home of `flask` integration.
         - `*/`: Future home of your favorite framework integration 🔌 ✨

{sqlspec-0.8.0 → sqlspec-0.9.1}/README.md

@@ -22,6 +22,145 @@ SQLSpec is an experimental Python library designed to streamline and modernize y
 
 SQLSpec is a work in progress. While it offers a solid foundation for modern SQL interactions, it does not yet include every feature you might find in a mature ORM or database toolkit. The focus is on building a robust, flexible core that can be extended over time.
 
+## Examples
+
+We've talked about what SQLSpec is not, so let's look at what it can do.
+
+These are just a few of the examples that demonstrate SQLSpec's flexibility and each of the bundled adapters offer the same config and driver interfaces.
+
+### DuckDB LLM
+
+This is a quick implementation using some of the built in Secret and Extension management features of SQLSpec's DuckDB integration.
+
+It allows you to communicate with any compatible OpenAPI conversations endpoint (such as Ollama).  This examples:
+
+- auto installs the `open_prompt` DuckDB extensions
+- automatically creates the correct `open_prompt` comptaible secret required to use the extension
+
+```py
+# /// script
+# dependencies = [
+#   "sqlspec[duckdb,performance]",
+# ]
+# ///
+import os
+
+from sqlspec import SQLSpec
+from sqlspec.adapters.duckdb import DuckDBConfig
+from pydantic import BaseModel
+
+class ChatMessage(BaseModel):
+    message: str
+
+sql = SQLSpec()
+etl_config = sql.add_config(
+    DuckDBConfig(
+        extensions=[{"name": "open_prompt"}],
+        secrets=[
+            {
+                "secret_type": "open_prompt",
+                "name": "open_prompt",
+                "value": {
+                    "api_url": "http://127.0.0.1:11434/v1/chat/completions",
+                    "model_name": "gemma3:1b",
+                    "api_timeout": "120",
+                },
+            }
+        ],
+    )
+)
+with sql.provide_session(etl_config) as session:
+    result = session.select_one("SELECT open_prompt(?)", data.message, schema_type=ChatMessage)
+    print(result) # result is a ChatMessage pydantic model
+```
+
+### DuckDB Gemini Embeddings
+
+In this example, we are again using DuckDB.  However, we are going to use the built in to call the Google Gemini embeddings service directly from the database.
+
+This example will
+
+- auto installs the `http_client` and `vss` (vector similarity search) DuckDB extensions
+- when a connection is created, it ensures that the `generate_embeddings` macro exists in the DuckDB database.
+- Execute a simple query to call the Google API
+
+```py
+# /// script
+# dependencies = [
+#   "sqlspec[duckdb,performance]",
+# ]
+# ///
+import os
+
+from sqlspec import SQLSpec
+from sqlspec.adapters.duckdb import DuckDBConfig
+
+EMBEDDING_MODEL = "gemini-embedding-exp-03-07"
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+API_URL = (
+    f"https://generativelanguage.googleapis.com/v1beta/models/{EMBEDDING_MODEL}:embedContent?key=${GOOGLE_API_KEY}"
+)
+
+sql = SQLSpec()
+etl_config = sql.add_config(
+    DuckDBConfig(
+        extensions=[{"name": "vss"}, {"name": "http_client"}],
+        on_connection_create=lambda connection: connection.execute(f"""
+            CREATE IF NOT EXISTS MACRO generate_embedding(q) AS (
+                WITH  __request AS (
+                    SELECT http_post(
+                        '{API_URL}',
+                        headers => MAP {{
+                            'accept': 'application/json',
+                        }},
+                        params => MAP {{
+                            'model': 'models/{EMBEDDING_MODEL}',
+                            'parts': [{{ 'text': q }}],
+                            'taskType': 'SEMANTIC_SIMILARITY'
+                        }}
+                    ) AS response
+                )
+                SELECT *
+                FROM __request,
+            );
+        """),
+    )
+)
+with sql.provide_session(etl_config) as session:
+    result = session.select_one("SELECT generate_embedding('example text')")
+    print(result) # result is a dictionary when `schema_type` is omitted.
+```
+
+### Basic Litestar Integration
+
+In this example we are going to demonstrate how to create a basic configuration that integrates into Litestar.
+
+```py
+# /// script
+# dependencies = [
+#   "sqlspec[aiosqlite]",
+#   "litestar[standard]",
+# ]
+# ///
+
+from aiosqlite import Connection
+from litestar import Litestar, get
+
+from sqlspec.adapters.aiosqlite import AiosqliteConfig, AiosqliteDriver
+from sqlspec.extensions.litestar import SQLSpec
+
+
+@get("/")
+async def simple_sqlite(db_session: AiosqliteDriver) -> dict[str, str]:
+    return await db_session.select_one("SELECT 'Hello, world!' AS greeting")
+
+
+sqlspec = SQLSpec(config=DatabaseConfig(
+    config=[AiosqliteConfig(), commit_mode="autocommit")],
+)
+app = Litestar(route_handlers=[simple_sqlite], plugins=[sqlspec])
+```
+
 ## Inspiration and Future Direction
 
 SQLSpec originally drew inspiration from features found in the `aiosql` library.  This is a great library for working with and executed SQL stored in files.  It's unclear how much of an overlap there will be between the two libraries, but it's possible that some features will be contributed back to `aiosql` where appropriate.
@@ -43,6 +182,7 @@ This list is not final. If you have a driver you'd like to see added, please ope
 | [`asyncpg`](https://magicstack.github.io/asyncpg/current/)                                                    | PostgreSQL | Async   | ✅         |
 | [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Sync    | ✅         |
 | [`psycopg`](https://www.psycopg.org/)                                                                         | PostgreSQL | Async   | ✅         |
+| [`psqlpy`](https://psqlpy-python.github.io/)                                                                  | PostgreSQL | Async   | ✅        |
 | [`aiosqlite`](https://github.com/omnilib/aiosqlite)                                                           | SQLite     | Async   | ✅         |
 | `sqlite3`                                                                                                    | SQLite     | Sync    | ✅         |
 | [`oracledb`](https://oracle.github.io/python-oracledb/)                                                      | Oracle     | Async   | ✅         |
@@ -59,7 +199,7 @@ This list is not final. If you have a driver you'd like to see added, please ope
 - `sqlspec/`:
     - `adapters/`: Contains all database drivers and associated configuration.
     - `extensions/`:
-        - `litestar/`: Future home of `litestar` integration.
+        - `litestar/`: Litestar framework integration ✅
         - `fastapi/`: Future home of `fastapi` integration.
         - `flask/`: Future home of `flask` integration.
         - `*/`: Future home of your favorite framework integration 🔌 ✨

{sqlspec-0.8.0 → sqlspec-0.9.1}/pyproject.toml

@@ -7,7 +7,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.9, <4.0"
-version = "0.8.0"
+version = "0.9.1"
 
 [project.optional-dependencies]
 adbc = ["adbc_driver_manager", "pyarrow"]
@@ -25,6 +25,7 @@ nanoid = ["fastnanoid>=0.4.1"]
 oracledb = ["oracledb"]
 orjson = ["orjson"]
 performance = ["sqlglot[rs]"]
+psqlpy = ["psqlpy"]
 psycopg = ["psycopg[binary,pool]"]
 pydantic = ["pydantic", "pydantic-extra-types"]
 pymssql = ["pymssql"]
@@ -108,7 +109,7 @@ packages = ["sqlspec"]
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.8.0"
+current_version = "0.9.1"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"
@@ -175,7 +176,7 @@ exclude_lines = [
 ]
 
 [tool.pytest.ini_options]
-addopts = "-ra -q --doctest-glob='*.md' --strict-markers --strict-config"
+addopts = ["-q", "-ra"]
 asyncio_default_fixture_loop_scope = "function"
 asyncio_mode = "auto"
 filterwarnings = [
@@ -189,8 +190,32 @@ filterwarnings = [
   "ignore::DeprecationWarning:websockets.connection",
   "ignore::DeprecationWarning:websockets.legacy",
 ]
+markers = [
+  "integration: marks tests that require an external database",
+  "postgres: marks tests specific to PostgreSQL",
+  "duckdb: marks tests specific to DuckDB",
+  "sqlite: marks tests specific to SQLite",
+  "bigquery: marks tests specific to Google BigQuery",
+  "mysql: marks tests specific to MySQL",
+  "oracle: marks tests specific to Oracle",
+  "spanner: marks tests specific to Google Cloud Spanner",
+  "mssql: marks tests specific to Microsoft SQL Server",
+  # Driver markers
+  "adbc: marks tests using ADBC drivers",
+  "aioodbc: marks tests using aioodbc",
+  "aiosqlite: marks tests using aiosqlite",
+  "asyncmy: marks tests using asyncmy",
+  "asyncpg: marks tests using asyncpg",
+  "duckdb_driver: marks tests using the duckdb driver",
+  "google_bigquery: marks tests using google-cloud-bigquery",
+  "google_spanner: marks tests using google-cloud-spanner",
+  "oracledb: marks tests using oracledb",
+  "psycopg: marks tests using psycopg",
+  "pymssql: marks tests using pymssql",
+  "pymysql: marks tests using pymysql",
+  "psqlpy: marks tests using psqlpy",
+]
 testpaths = ["tests"]
-xfail_strict = true
 
 [tool.mypy]
 packages = ["sqlspec", "tests"]
@@ -220,6 +245,8 @@ module = [
   "uvloop.*",
   "asyncmy",
   "asyncmy.*",
+  "pyarrow",
+  "pyarrow.*",
 ]
 
 [tool.pyright]

{sqlspec-0.8.0 → sqlspec-0.9.1}/sqlspec/_typing.py

@@ -1,8 +1,10 @@
+# ruff: noqa: RUF100, PLR0913, A002, DOC201, PLR6301
 """This is a simple wrapper around a few important classes in each library.
 
 This is used to ensure compatibility when one or more of the libraries are installed.
 """
 
+from collections.abc import Iterable, Mapping
 from enum import Enum
 from typing import (
     Any,
@@ -96,7 +98,7 @@ except ImportError:
 
         def validate_python(
             self,
-            object: Any,  # noqa: A002
+            object: Any,
             /,
             *,
             strict: "Optional[bool]" = None,
@@ -127,10 +129,7 @@ try:
 except ImportError:
     import enum
     from collections.abc import Iterable
-    from typing import TYPE_CHECKING, Callable, Optional, Union
-
-    if TYPE_CHECKING:
-        from collections.abc import Iterable
+    from typing import Callable, Optional, Union
 
     @dataclass_transform()
     @runtime_checkable
@@ -174,7 +173,6 @@ except ImportError:
             """Placeholder init"""
 
         def create_instance(self, **kwargs: Any) -> "T":
-            """Placeholder implementation"""
             return cast("T", kwargs)
 
         def update_instance(self, instance: "T", **kwargs: Any) -> "T":
@@ -198,11 +196,46 @@ EmptyType = Union[Literal[EmptyEnum.EMPTY], UnsetType]
 Empty: Final = EmptyEnum.EMPTY
 
 
+try:
+    from pyarrow import Table as ArrowTable
+
+    PYARROW_INSTALLED = True
+except ImportError:
+
+    @runtime_checkable
+    class ArrowTable(Protocol):  # type: ignore[no-redef]
+        """Placeholder Implementation"""
+
+        def to_batches(self, batch_size: int) -> Any: ...
+        def num_rows(self) -> int: ...
+        def num_columns(self) -> int: ...
+        def to_pydict(self) -> dict[str, Any]: ...
+        def to_string(self) -> str: ...
+        def from_arrays(
+            self,
+            arrays: list[Any],
+            names: "Optional[list[str]]" = None,
+            schema: "Optional[Any]" = None,
+            metadata: "Optional[Mapping[str, Any]]" = None,
+        ) -> Any: ...
+        def from_pydict(
+            self,
+            mapping: dict[str, Any],
+            schema: "Optional[Any]" = None,
+            metadata: "Optional[Mapping[str, Any]]" = None,
+        ) -> Any: ...
+        def from_batches(self, batches: Iterable[Any], schema: Optional[Any] = None) -> Any: ...
+
+    PYARROW_INSTALLED = False  # pyright: ignore[reportConstantRedefinition]
+
+
 __all__ = (
     "LITESTAR_INSTALLED",
     "MSGSPEC_INSTALLED",
+    "PYARROW_INSTALLED",
     "PYDANTIC_INSTALLED",
     "UNSET",
+    "ArrowTable",
     "BaseModel",
     "DTOData",
     "DataclassProtocol",

{sqlspec-0.8.0 → sqlspec-0.9.1}/sqlspec/adapters/adbc/__init__.py

@@ -1,7 +1,7 @@
-from sqlspec.adapters.adbc.config import Adbc
+from sqlspec.adapters.adbc.config import AdbcConfig
 from sqlspec.adapters.adbc.driver import AdbcDriver
 
 __all__ = (
-    "Adbc",
+    "AdbcConfig",
     "AdbcDriver",
 )

{sqlspec-0.8.0 → sqlspec-0.9.1}/sqlspec/adapters/adbc/config.py

@@ -14,11 +14,11 @@ if TYPE_CHECKING:
     from collections.abc import Generator
 
 
-__all__ = ("Adbc",)
+__all__ = ("AdbcConfig",)
 
 
 @dataclass
-class Adbc(NoPoolSyncConfig["Connection", "AdbcDriver"]):
+class AdbcConfig(NoPoolSyncConfig["Connection", "AdbcDriver"]):
     """Configuration for ADBC connections.
 
     This class provides configuration options for ADBC database connections using the
@@ -55,17 +55,41 @@ class Adbc(NoPoolSyncConfig["Connection", "AdbcDriver"]):
         """
 
         if isinstance(self.driver_name, str):
-            if self.driver_name != "adbc_driver_sqlite.dbapi.connect" and "sqlite" in self.driver_name:
+            if self.driver_name != "adbc_driver_sqlite.dbapi.connect" and self.driver_name in {
+                "sqlite",
+                "sqlite3",
+                "adbc_driver_sqlite",
+            }:
                 self.driver_name = "adbc_driver_sqlite.dbapi.connect"
-            elif self.driver_name != "adbc_driver_duckdb.dbapi.connect" and "duckdb" in self.driver_name:
+            elif self.driver_name != "adbc_driver_duckdb.dbapi.connect" and self.driver_name in {
+                "duckdb",
+                "adbc_driver_duckdb",
+            }:
                 self.driver_name = "adbc_driver_duckdb.dbapi.connect"
-            elif self.driver_name != "adbc_driver_postgresql.dbapi.connect" and "postgres" in self.driver_name:
+            elif self.driver_name != "adbc_driver_postgresql.dbapi.connect" and self.driver_name in {
+                "postgres",
+                "adbc_driver_postgresql",
+                "postgresql",
+                "pg",
+            }:
                 self.driver_name = "adbc_driver_postgresql.dbapi.connect"
-            elif self.driver_name != "adbc_driver_snowflake.dbapi.connect" and "snowflake" in self.driver_name:
+            elif self.driver_name != "adbc_driver_snowflake.dbapi.connect" and self.driver_name in {
+                "snowflake",
+                "adbc_driver_snowflake",
+                "sf",
+            }:
                 self.driver_name = "adbc_driver_snowflake.dbapi.connect"
-            elif self.driver_name != "adbc_driver_bigquery.dbapi.connect" and "bigquery" in self.driver_name:
+            elif self.driver_name != "adbc_driver_bigquery.dbapi.connect" and self.driver_name in {
+                "bigquery",
+                "adbc_driver_bigquery",
+                "bq",
+            }:
                 self.driver_name = "adbc_driver_bigquery.dbapi.connect"
-            elif self.driver_name != "adbc_driver_flightsql.dbapi.connect" and "flightsql" in self.driver_name:
+            elif self.driver_name != "adbc_driver_flightsql.dbapi.connect" and self.driver_name in {
+                "flightsql",
+                "adbc_driver_flightsql",
+                "grpc",
+            }:
                 self.driver_name = "adbc_driver_flightsql.dbapi.connect"
             return self.driver_name
 
@@ -153,11 +177,10 @@ class Adbc(NoPoolSyncConfig["Connection", "AdbcDriver"]):
         """
         try:
             connect_func = self._get_connect_func()
-            _config = self.connection_config_dict
-            return connect_func(**_config)
+            return connect_func(**self.connection_config_dict)
         except Exception as e:
             # Include driver name in error message for better context
-            driver_name = self.driver_name if isinstance(self.driver_name, str) else "Unknown/Derived"
+            driver_name = self.driver_name if isinstance(self.driver_name, str) else "Unknown/Missing"
             # Use the potentially modified driver_path from _get_connect_func if available,
             # otherwise fallback to self.driver_name for the error message.
             # This requires _get_connect_func to potentially return the used path or store it.