ob-postgres 2.1.0__tar.gz → 2.36.0__tar.gz

ob_postgres-2.36.0/.gitignore

@@ -0,0 +1,67 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+dist/
+build/
+*.egg-info/
+*.egg
+.eggs/
+.venv/
+venv/
+.env
+*.db
+*.duckdb
+# Generated FOCUS export (20 MB); rebuilt by scripts/build_finops_duckdb.py.
+# The committed excerpt is examples/finops_charges_sample.json.
+examples/finops_data/
+*.sqlite3
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+htmlcov/
+.coverage
+.coverage.*
+*.log
+.DS_Store
+.claude/
+# Playwright MCP scratch output: accessibility snapshots and console logs
+# written per browser session. The console logs were already caught by
+# *.log above, which left only the .yml page dumps showing as untracked.
+.playwright-mcp/
+# Playwright writes screenshots to the working directory when the tool is
+# given a bare filename, which is the repo root. Twice now one has been
+# swept into a commit by ``git add -A``.
+*.playwright.png
+gradio*-production.png
+ui-gradio*.png
+/cache/
+/usage/
+security/
+infra/
+site/
+scripts-infra
+.mcpregistry_github_token
+.mcpregistry_registry_token
+_*/
+blog/
+review*
+design/
+examples/test*
+# TPC-DS sweep harness. The queries, the runner and the compiled SQL are
+# published so the coverage is auditable; the generated database, the working
+# notes and the drafts that do not yet match the reference are not.
+examples/tpcds_queries/*
+!examples/tpcds_queries/README.md
+!examples/tpcds_queries/sweep.py
+!examples/tpcds_queries/Q*.yml
+!examples/tpcds_queries/sql/
+examples/tpcds_queries/*.duckdb
+examples/tpcds_queries/REPORT.md
+examples/tpcds_queries/tpcds_run.py
+examples/tpcds_queries/drafts/
+semantic-layer-spec.md
+
+# Generated per-vendor seed scripts (backup of what the drift seed executed)
+tests/integration/drift/vendor_exec/seed_sql/
+examples/tpcds_queries/results/

ob_postgres-2.36.0/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

{ob_postgres-2.1.0 → ob_postgres-2.36.0}/LICENSE

@@ -3,8 +3,8 @@ Business Source License 1.1
 Parameters
 
 Licensor:             RALFORION d.o.o.
-Licensed Work:        OrionBelt Semantic Layer 1.0
-                      The Licensed Work is (c) 2025 RALFORION d.o.o.
+Licensed Work:        OrionBelt Semantic Layer (all versions)
+                      The Licensed Work is (c) 2025-2026 RALFORION d.o.o.
 Additional Use Grant: You may use the Licensed Work for any purpose,
                       including production use, PROVIDED THAT you may
                       not embed OrionBelt in a commercial product or

{ob_postgres-2.1.0 → ob_postgres-2.36.0}/PKG-INFO

@@ -1,14 +1,14 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ob-postgres
-Version: 2.1.0
+Version: 2.36.0
 Summary: OrionBelt Semantic Layer driver for PostgreSQL (DB-API 2.0)
 Author-email: Ralf Becher <info@orionbelt.ai>
-License: BSL-1.1
+License-Expression: BUSL-1.1
 License-File: LICENSE
 Keywords: db-api,obml,orionbelt,postgres,semantic-layer
 Requires-Python: >=3.12
 Requires-Dist: adbc-driver-postgresql>=1.0
-Requires-Dist: ob-driver-core>=0.1
+Requires-Dist: ob-driver-core>=2.36.0
 Requires-Dist: pyarrow>=16.0
 Provides-Extra: dev
 Requires-Dist: mypy>=1.10; extra == 'dev'
@@ -24,7 +24,7 @@ Description-Content-Type: text/markdown
 
 OrionBelt Semantic Layer driver for PostgreSQL (DB-API 2.0)
 
-Part of the [OrionBelt Semantic Layer](https://github.com/ralfbecher/orionbelt-semantic-layer) project.
+Part of the [OrionBelt Semantic Layer](https://github.com/ralforion/orionbelt-semantic-layer) project.
 
 ## Installation
 
@@ -34,4 +34,4 @@ pip install ob-postgres
 
 ## License
 
-BSL-1.1 — see [LICENSE](LICENSE) for details.
+BUSL-1.1 — see [LICENSE](LICENSE) for details.

ob_postgres-2.36.0/README.md

@@ -0,0 +1,15 @@
+# ob-postgres
+
+OrionBelt Semantic Layer driver for PostgreSQL (DB-API 2.0)
+
+Part of the [OrionBelt Semantic Layer](https://github.com/ralforion/orionbelt-semantic-layer) project.
+
+## Installation
+
+```bash
+pip install ob-postgres
+```
+
+## License
+
+BUSL-1.1 — see [LICENSE](LICENSE) for details.

{ob_postgres-2.1.0 → ob_postgres-2.36.0}/pyproject.toml

@@ -4,15 +4,16 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ob-postgres"
-version = "2.1.0"
+version = "2.36.0"
 description = "OrionBelt Semantic Layer driver for PostgreSQL (DB-API 2.0)"
-license = { text = "BSL-1.1" }
+license = "BUSL-1.1"
+license-files = ["LICENSE"]
 readme = "README.md"
 authors = [{ name = "Ralf Becher", email = "info@orionbelt.ai" }]
 keywords = ["postgres", "semantic-layer", "obml", "db-api", "orionbelt"]
 requires-python = ">=3.12"
 dependencies = [
-    "ob-driver-core>=0.1",
+    "ob-driver-core>=2.36.0",
     "adbc-driver-postgresql>=1.0",
     "pyarrow>=16.0",
 ]
@@ -39,12 +40,28 @@ target-version = "py312"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "B", "SIM", "ANN"]
+ignore = [
+    # PEP 249 is an untyped boundary by specification: ``execute()`` takes
+    # whatever the caller passes, and every cursor wraps a native object no
+    # vendor annotates. ``Any`` there is the honest signature, not a missing one.
+    "ANN401",
+]
+
+[tool.ruff.lint.per-file-ignores]
+# A test reads better with its patches nested, and its return type says nothing
+# a reader needs.
+"tests/**" = ["ANN001", "ANN201", "SIM117"]
 
 [tool.mypy]
 python_version = "3.12"
 strict = true
 files = ["src/ob_postgres"]
 
+# Untyped upstream - neither ships a py.typed marker.
+[[tool.mypy.overrides]]
+module = ["pyarrow.*", "adbc_driver_postgresql.*"]
+ignore_missing_imports = true
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]

{ob_postgres-2.1.0 → ob_postgres-2.36.0}/src/ob_postgres/cursor.py

@@ -11,7 +11,7 @@ from typing import Any
 
 from ob_postgres.compiler import compile_obml, is_obml, parse_obml
 from ob_postgres.exceptions import NotSupportedError, ProgrammingError
-from ob_postgres.type_codes import PG_OID_MAP, STRING
+from ob_postgres.type_codes import BINARY, DATETIME, NUMBER, PG_OID_MAP, STRING
 
 
 class Cursor:
@@ -42,7 +42,14 @@ class Cursor:
     def description(
         self,
     ) -> tuple[tuple[str, Any, None, None, None, None, None], ...] | None:
-        """PEP 249 cursor description — 7-item tuples per column."""
+        """PEP 249 cursor description — 7-item tuples per column.
+
+        ``adbc-driver-postgresql`` returns PyArrow ``DataType`` objects
+        (or ``OpaqueType`` for vendor-specific types like ``numeric``)
+        as the ``type_code`` slot. psycopg2 returns OID integers. We
+        handle both so downstream type-hint mapping (``_map_type_code``
+        in db_executor.py) sees the right PEP 249 type constant.
+        """
         native_desc = self._native.description
         if native_desc is None:
             return None
@@ -50,14 +57,20 @@ class Cursor:
         for col in native_desc:
             name = col[0]
             type_code = col[1]
-            # ADBC PG driver may return OIDs or other type identifiers
-            mapped = PG_OID_MAP.get(type_code, STRING) if isinstance(type_code, int) else STRING
+            mapped = _classify_type_code(type_code)
             cols.append((name, mapped, None, None, None, None, None))
         return tuple(cols)
 
     @property
     def rowcount(self) -> int:
-        return self._native.rowcount
+        """Rows the last statement produced, or -1 where the driver says nothing.
+
+        ``self._native`` is untyped, so the value arrives as ``Any``; PEP 249
+        promises an ``int`` and -1 is what it reserves for "unknown", which is
+        what a connector answering ``None`` means.
+        """
+        count = self._native.rowcount
+        return int(count) if isinstance(count, int) else -1
 
     def _check_open(self) -> None:
         if self._closed:
@@ -156,3 +169,76 @@ class Cursor:
         if row is None:
             raise StopIteration
         return row
+
+
+# Substrings inside an OpaqueType's repr that identify the underlying
+# Postgres type. ADBC wraps types it can't represent natively (NUMERIC,
+# MONEY, JSON, …) in ``OpaqueType`` whose repr embeds ``type_name=<pg>``.
+_OPAQUE_NUMBER_NAMES = ("numeric", "money", "decimal")
+_OPAQUE_DATETIME_NAMES = ("timestamp", "date", "time", "interval")
+_OPAQUE_BINARY_NAMES = ("bytea",)
+
+
+def _classify_type_code(type_code: object) -> object:
+    """Map a native ADBC type identifier to a PEP 249 type constant.
+
+    ADBC's PostgreSQL driver populates ``cursor.description[i][1]``
+    with PyArrow ``DataType`` objects — ``DataType(int32)``,
+    ``TimestampType(timestamp[us, tz=UTC])``, ``DataType(string)`` —
+    plus ``OpaqueType`` wrappers for types Arrow can't natively
+    represent (NUMERIC ends up as
+    ``OpaqueType(extension<arrow.opaque[storage_type=string,
+    type_name=numeric, vendor_name=PostgreSQL]>)``).
+    The legacy psycopg2 path supplies OID integers, kept for
+    compatibility.
+    """
+
+    # psycopg2 / classic PEP 249 — bare OID.
+    if isinstance(type_code, int):
+        return PG_OID_MAP.get(type_code, STRING)
+
+    # ADBC native PyArrow types — use pyarrow.types helpers when the
+    # module is importable. ``pa.types.is_*`` calls ``t.id`` internally,
+    # so an unrelated object (OpaqueType subclass, mock, etc.) trips
+    # ``AttributeError`` — catch that and fall through to the
+    # repr-substring branch below.
+    try:
+        import pyarrow as pa
+
+        try:
+            if pa.types.is_integer(type_code):
+                return NUMBER
+            if pa.types.is_floating(type_code) or pa.types.is_decimal(type_code):
+                return NUMBER
+            if pa.types.is_boolean(type_code):
+                return STRING
+            if (
+                pa.types.is_timestamp(type_code)
+                or pa.types.is_date(type_code)
+                or pa.types.is_time(type_code)
+                or pa.types.is_duration(type_code)
+            ):
+                return DATETIME
+            if (
+                pa.types.is_binary(type_code)
+                or pa.types.is_large_binary(type_code)
+                or pa.types.is_fixed_size_binary(type_code)
+            ):
+                return BINARY
+            if pa.types.is_string(type_code) or pa.types.is_large_string(type_code):
+                return STRING
+        except (AttributeError, TypeError):
+            pass
+    except ImportError:
+        pass
+
+    # OpaqueType (NUMERIC, MONEY, JSON, …) — the type's repr embeds
+    # ``type_name=<pg type>``. Match against the substring lists.
+    s = str(type_code).lower()
+    if any(name in s for name in _OPAQUE_NUMBER_NAMES):
+        return NUMBER
+    if any(name in s for name in _OPAQUE_DATETIME_NAMES):
+        return DATETIME
+    if any(name in s for name in _OPAQUE_BINARY_NAMES):
+        return BINARY
+    return STRING

{ob_postgres-2.1.0 → ob_postgres-2.36.0}/src/ob_postgres/type_codes.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 from ob_driver_core.type_codes import BINARY, DATETIME, NUMBER, ROWID, STRING
 
-__all__ = ["STRING", "BINARY", "NUMBER", "DATETIME", "ROWID", "PG_OID_MAP"]
+__all__ = ["BINARY", "DATETIME", "NUMBER", "PG_OID_MAP", "ROWID", "STRING"]
 
 # Common PostgreSQL OIDs — see pg_type catalog
 # https://www.postgresql.org/docs/current/catalog-pg-type.html

{ob_postgres-2.1.0 → ob_postgres-2.36.0}/tests/test_driver.py

@@ -16,14 +16,15 @@ from ob_postgres.connection import Connection
 from ob_postgres.exceptions import NotSupportedError, ProgrammingError
 from ob_postgres.type_codes import DATETIME, NUMBER, STRING
 
-
 # ---------------------------------------------------------------------------
 # Helper to build a mock psycopg2 connection
 # ---------------------------------------------------------------------------
 
 # psycopg2 description columns are named tuples
-PgColumn = namedtuple("Column", ["name", "type_code", "display_size",
-                                 "internal_size", "precision", "scale", "null_ok"])
+PgColumn = namedtuple(
+    "Column",
+    ["name", "type_code", "display_size", "internal_size", "precision", "scale", "null_ok"],
+)
 
 
 def _make_mock_native() -> MagicMock:
@@ -62,7 +63,10 @@ def test_threadsafety() -> None:
 
 
 def test_paramstyle() -> None:
-    assert ob_postgres.paramstyle == "format"
+    # ADBC uses ``?`` placeholders — paramstyle ``qmark``. The legacy
+    # psycopg2-based driver used ``%s`` (``format``); the migration to
+    # ``adbc-driver-postgresql`` changed this.
+    assert ob_postgres.paramstyle == "qmark"
 
 
 # ---------------------------------------------------------------------------
@@ -71,27 +75,30 @@ def test_paramstyle() -> None:
 
 
 def test_connect_returns_connection() -> None:
-    with patch("psycopg2.connect") as mock_connect:
+    with patch("adbc_driver_postgresql.dbapi.connect") as mock_connect:
         mock_connect.return_value = _make_mock_native()
         conn = ob_postgres.connect(dbname="testdb", user="testuser")
         assert isinstance(conn, Connection)
         mock_connect.assert_called_once()
-        kwargs = mock_connect.call_args.kwargs
-        assert kwargs["dbname"] == "testdb"
-        assert kwargs["user"] == "testuser"
+        # ADBC takes a URI as its first positional arg — the kwargs are
+        # encoded into it. Verify both made the trip.
+        (uri,) = mock_connect.call_args.args
+        assert "testdb" in uri
+        assert "testuser" in uri
 
 
 def test_connect_with_dsn() -> None:
-    with patch("psycopg2.connect") as mock_connect:
+    with patch("adbc_driver_postgresql.dbapi.connect") as mock_connect:
         mock_connect.return_value = _make_mock_native()
-        conn = ob_postgres.connect(dsn="host=localhost dbname=mydb")
+        dsn = "postgresql://localhost:5432/mydb"
+        conn = ob_postgres.connect(dsn=dsn)
         assert isinstance(conn, Connection)
-        kwargs = mock_connect.call_args.kwargs
-        assert kwargs["dsn"] == "host=localhost dbname=mydb"
+        (uri,) = mock_connect.call_args.args
+        assert uri == dsn
 
 
 def test_connect_context_manager() -> None:
-    with patch("psycopg2.connect") as mock_connect:
+    with patch("adbc_driver_postgresql.dbapi.connect") as mock_connect:
         mock_native = _make_mock_native()
         mock_connect.return_value = mock_native
         with ob_postgres.connect() as conn:
@@ -167,8 +174,8 @@ def test_cursor_description() -> None:
     mock_native = _make_mock_native()
     mock_cursor = mock_native.cursor()
     mock_cursor.description = [
-        PgColumn("num", 23, None, None, None, None, None),   # int4 → NUMBER
-        PgColumn("txt", 25, None, None, None, None, None),   # text → STRING
+        PgColumn("num", 23, None, None, None, None, None),  # int4 → NUMBER
+        PgColumn("txt", 25, None, None, None, None, None),  # text → STRING
         PgColumn("dt", 1114, None, None, None, None, None),  # timestamp → DATETIME
     ]
     conn = Connection(mock_native)
@@ -185,6 +192,63 @@ def test_cursor_description() -> None:
     assert desc[2][1] == DATETIME
 
 
+def test_cursor_description_classifies_arrow_datatypes() -> None:
+    """ADBC returns PyArrow ``DataType`` objects, not OIDs.
+
+    The legacy code path checked ``isinstance(type_code, int)`` and
+    fell back to ``STRING`` for everything else — which caused every
+    column from a live ADBC PostgreSQL connection to surface as TEXT,
+    breaking Tableau (NUMERIC measures decoded as strings → SUM = 0).
+    """
+
+    import pyarrow as pa
+
+    mock_native = _make_mock_native()
+    mock_cursor = mock_native.cursor()
+    mock_cursor.description = [
+        PgColumn("a", pa.int32(), None, None, None, None, None),
+        PgColumn("b", pa.float64(), None, None, None, None, None),
+        PgColumn("c", pa.string(), None, None, None, None, None),
+        PgColumn("d", pa.timestamp("us"), None, None, None, None, None),
+        PgColumn("e", pa.binary(), None, None, None, None, None),
+    ]
+    conn = Connection(mock_native)
+    cur = conn.cursor()
+    desc = cur.description
+    assert desc is not None
+    assert desc[0][1] == NUMBER  # int32
+    assert desc[1][1] == NUMBER  # float64
+    assert desc[2][1] == STRING  # string
+    assert desc[3][1] == DATETIME  # timestamp
+    from ob_postgres.type_codes import BINARY
+
+    assert desc[4][1] == BINARY  # binary
+
+
+def test_cursor_description_classifies_opaque_numeric() -> None:
+    """ADBC wraps Postgres NUMERIC in an OpaqueType — repr contains ``type_name=numeric``.
+
+    Falls through pa.types.is_decimal() (which only matches Arrow
+    DecimalType) and into the OpaqueType repr-substring branch.
+    """
+
+    class _FakeOpaque:
+        def __repr__(self) -> str:
+            return (
+                "OpaqueType(extension<arrow.opaque[storage_type=string, "
+                "type_name=numeric, vendor_name=PostgreSQL]>)"
+            )
+
+    mock_native = _make_mock_native()
+    mock_native.cursor().description = [
+        PgColumn("total_sales", _FakeOpaque(), None, None, None, None, None),
+    ]
+    cur = Connection(mock_native).cursor()
+    desc = cur.description
+    assert desc is not None
+    assert desc[0][1] == NUMBER
+
+
 def test_cursor_description_none_before_execute() -> None:
     mock_native = _make_mock_native()
     mock_native.cursor().description = None
@@ -309,7 +373,9 @@ def test_obml_compile_and_execute() -> None:
         PgColumn("revenue", 701, None, None, None, None, None),
     ]
     mock_native.cursor().fetchall.return_value = [
-        ("EMEA", 300.0), ("APAC", 150.0), ("AMER", 550.0),
+        ("EMEA", 300.0),
+        ("APAC", 150.0),
+        ("AMER", 550.0),
     ]
     conn = Connection(mock_native)
     with patch("httpx.post", return_value=_mock_api_response(compiled_sql)):
@@ -350,8 +416,7 @@ def test_plain_sql_passthrough() -> None:
     """Plain SQL is passed through without OBML compilation — no REST call."""
     mock_native = _make_mock_native()
     conn = Connection(mock_native)
-    with patch("httpx.post") as mock_post:
-        with conn.cursor() as cur:
-            cur.execute("SELECT COUNT(*) FROM orders")
-            mock_post.assert_not_called()
-            mock_native.cursor().execute.assert_called_once_with("SELECT COUNT(*) FROM orders")
+    with patch("httpx.post") as mock_post, conn.cursor() as cur:
+        cur.execute("SELECT COUNT(*) FROM orders")
+        mock_post.assert_not_called()
+        mock_native.cursor().execute.assert_called_once_with("SELECT COUNT(*) FROM orders")

ob_postgres-2.36.0/tests/test_yaml_detection.py

@@ -0,0 +1,34 @@
+"""Unit tests for OBML YAML detection — no external services required."""
+
+import pytest
+
+from ob_postgres.compiler import is_obml, parse_obml
+
+
+@pytest.mark.parametrize(
+    "query,expected",
+    [
+        ("select:\n  dimensions:\n    - Region\n  measures:\n    - Revenue\n", True),
+        ("select:\n  measures:\n    - Revenue\n", True),
+        ("select:\n  dimensions:\n    - Country\n", True),
+        ("SELECT:\n  dimensions:\n    - X\n", True),
+        ("   select:\n  dimensions:\n    - X\n", True),
+        ("SELECT * FROM orders", False),
+        ("SELECT id\nFROM customers WHERE id = 1", False),
+        ("", False),
+        ("model:\n  name: test\n", False),
+        ("select:\n  filters:\n    - x = 1\n", False),
+        ("select:\n  - [unclosed", False),
+        ("select:\n  - dimension1\n", False),
+    ],
+)
+def test_obml_detection(query, expected):
+    assert is_obml(query) == expected
+
+
+def test_parse_obml_returns_dict():
+    q = "select:\n  dimensions:\n    - Region\n  measures:\n    - Revenue\nlimit: 100\n"
+    result = parse_obml(q)
+    assert result["select"]["dimensions"] == ["Region"]
+    assert result["select"]["measures"] == ["Revenue"]
+    assert result["limit"] == 100

ob_postgres-2.1.0/.gitignore

@@ -1,37 +0,0 @@
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-dist/
-build/
-*.egg-info/
-*.egg
-.eggs/
-.venv/
-venv/
-.env
-*.db
-*.duckdb
-*.sqlite3
-.mypy_cache/
-.ruff_cache/
-.pytest_cache/
-htmlcov/
-.coverage
-.coverage.*
-*.log
-.DS_Store
-.claude/
-security/
-infra/
-site/
-scripts/
-.mcpregistry_github_token
-.mcpregistry_registry_token
-_*/
-blog/
-review*
-design/
-examples/test*
-examples/tpcds_queries/
-semantic-layer-spec.md

ob_postgres-2.1.0/README.md

@@ -1,15 +0,0 @@
-# ob-postgres
-
-OrionBelt Semantic Layer driver for PostgreSQL (DB-API 2.0)
-
-Part of the [OrionBelt Semantic Layer](https://github.com/ralfbecher/orionbelt-semantic-layer) project.
-
-## Installation
-
-```bash
-pip install ob-postgres
-```
-
-## License
-
-BSL-1.1 — see [LICENSE](LICENSE) for details.

ob_postgres-2.1.0/tests/test_yaml_detection.py

@@ -1,29 +0,0 @@
-"""Unit tests for OBML YAML detection — no external services required."""
-import pytest
-from ob_postgres.compiler import is_obml, parse_obml
-
-
-@pytest.mark.parametrize("query,expected", [
-    ("select:\n  dimensions:\n    - Region\n  measures:\n    - Revenue\n", True),
-    ("select:\n  measures:\n    - Revenue\n", True),
-    ("select:\n  dimensions:\n    - Country\n", True),
-    ("SELECT:\n  dimensions:\n    - X\n", True),
-    ("   select:\n  dimensions:\n    - X\n", True),
-    ("SELECT * FROM orders", False),
-    ("SELECT id\nFROM customers WHERE id = 1", False),
-    ("", False),
-    ("model:\n  name: test\n", False),
-    ("select:\n  filters:\n    - x = 1\n", False),
-    ("select:\n  - [unclosed", False),
-    ("select:\n  - dimension1\n", False),
-])
-def test_obml_detection(query, expected):
-    assert is_obml(query) == expected
-
-
-def test_parse_obml_returns_dict():
-    q = "select:\n  dimensions:\n    - Region\n  measures:\n    - Revenue\nlimit: 100\n"
-    result = parse_obml(q)
-    assert result["select"]["dimensions"] == ["Region"]
-    assert result["select"]["measures"] == ["Revenue"]
-    assert result["limit"] == 100

{ob_postgres-2.1.0 → ob_postgres-2.36.0}/src/ob_postgres/__init__.py

@@ -139,19 +139,19 @@ def connect(
 
 
 __all__ = [
-    "apilevel",
-    "threadsafety",
-    "paramstyle",
-    "connect",
     "Connection",
-    "Warning",
-    "Error",
-    "InterfaceError",
-    "DatabaseError",
     "DataError",
-    "OperationalError",
+    "DatabaseError",
+    "Error",
     "IntegrityError",
+    "InterfaceError",
     "InternalError",
-    "ProgrammingError",
     "NotSupportedError",
+    "OperationalError",
+    "ProgrammingError",
+    "Warning",
+    "apilevel",
+    "connect",
+    "paramstyle",
+    "threadsafety",
 ]

{ob_postgres-2.1.0 → ob_postgres-2.36.0}/src/ob_postgres/exceptions.py

@@ -6,8 +6,8 @@ Allows users to do: ``from ob_postgres.exceptions import ProgrammingError``
 from __future__ import annotations
 
 from ob_driver_core.exceptions import (
-    DataError,
     DatabaseError,
+    DataError,
     Error,
     IntegrityError,
     InterfaceError,
@@ -19,14 +19,14 @@ from ob_driver_core.exceptions import (
 )
 
 __all__ = [
-    "Warning",
-    "Error",
-    "InterfaceError",
-    "DatabaseError",
     "DataError",
-    "OperationalError",
+    "DatabaseError",
+    "Error",
     "IntegrityError",
+    "InterfaceError",
     "InternalError",
-    "ProgrammingError",
     "NotSupportedError",
+    "OperationalError",
+    "ProgrammingError",
+    "Warning",
 ]