pyapiary 2.2.0__tar.gz → 2.3.0__tar.gz

{pyapiary-2.2.0 → pyapiary-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyapiary
-Version: 2.2.0
+Version: 2.3.0
 Summary: A simple, lightweight set of connectors and functions to various APIs and DBMSs, controlled by a central broker.
 Author: Rob D'Aveta
 Author-email: rob.daveta@gmail.com
@@ -22,6 +22,7 @@ Requires-Dist: pyodbc (>=5.3.0,<6.0.0) ; extra == "odbc"
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: splunk-sdk (>=2.1.1,<3.0.0)
 Requires-Dist: tenacity (>=9.1.2,<10.0.0)
+Requires-Dist: trino (>=0.337.0,<0.338.0)
 Project-URL: Homepage, https://github.com/robd518/pyapiary
 Project-URL: Repository, https://github.com/robd518/pyapiary
 Description-Content-Type: text/markdown

{pyapiary-2.2.0 → pyapiary-2.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "pyapiary"
 packages = [{ include = "pyapiary", from = "src" }]
-version = "2.2.0"
+version = "2.3.0"
 description = "A simple, lightweight set of connectors and functions to various APIs and DBMSs, controlled by a central broker."
 authors = ["Rob D'Aveta <rob.daveta@gmail.com>"]
 readme = "README.md"
@@ -20,6 +20,7 @@ pyodbc = "^5.3.0"
 psycopg-pool = {extras = ["binary", "pool"], version = "^3.3.1"}
 psycopg = {extras = ["pool"], version = "^3.3.4"}
 psycopg-binary = "^3.3.4"
+trino = "^0.337.0"
 
 [tool.poetry.extras]
 odbc = ["pyodbc"]

{pyapiary-2.2.0 → pyapiary-2.3.0}/src/pyapiary/dbms_connectors/postgres.py

@@ -35,9 +35,13 @@ class PostgresConnector:
         https://www.psycopg.org/psycopg3/docs/api/pool.html#module-psycopg_pool
         """
         with self.connection_pool.connection() as conn:
-            with conn.transaction():
+            with conn.cursor() as cur:
                 # claude recommended a transaction wrapper here
-                return conn.execute(query, params).fetchall()
+                cur.execute(query, params)
+                if cur.description:
+                    return cur.fetchall()
+                else:
+                    return None
 
     def bulk_insert(self, table: str, data: List[Dict[str, Any]]):
         if not data:
@@ -82,7 +86,10 @@ class AsyncPostgresConnector:
         """
         async with self.connection_pool.connection() as conn:
             cur = await conn.execute(query, params)
-            return await cur.fetchall()
+            if cur.description:
+                return await cur.fetchall()
+            else:
+                return None
 
     async def async_bulk_insert(self, table_name: str, data: List[Dict[str, Any]]):
         if not data:

pyapiary-2.3.0/src/pyapiary/dbms_connectors/trino.py

@@ -0,0 +1,32 @@
+from trino.dbapi import connect
+from typing import List, Dict, Any
+
+class TrinoConnector:
+    def __init__(self, host, port, user, catalog=None, schema=None):
+        self.conn = connect(
+            host=host,
+            port=port,
+            user=user,
+            catalog=catalog,
+            schema=schema
+        )
+    
+    def query(self, query_str):
+        with self.conn.cursor() as cur:
+            cur.execute(query_str)
+            if cur.description:
+                return cur.fetchall()
+            else:
+                return None
+    
+    def bulk_insert(self, table, data : List[Dict[str,Any]]):
+        if not len(data)>0:
+            print('Invalid List of Dict type passed. Must have more than one element.')
+            return None
+        columns = data[0].keys()
+        placeholders = ", ".join(["?"] * len(columns))
+        query = f"INSERT INTO {table} ({', '.join(columns)}) VALUES ({placeholders})"
+        values = [tuple(row[col] for col in columns) for row in data]
+        with self.conn.cursor() as cur:
+            cur.executemany(query, values)
+            return True

{pyapiary-2.2.0 → pyapiary-2.3.0}/src/pyapiary/tests/test_postgres/test_unit_postgres.py

@@ -3,13 +3,26 @@ from unittest.mock import MagicMock, AsyncMock, patch
 
 import pytest
 
-# Mock psycopg_pool before importing the module so tests run even when the
-# driver is not installed in the environment.
 sys.modules.setdefault("psycopg_pool", MagicMock())
 
 from pyapiary.dbms_connectors.postgres import PostgresConnector, AsyncPostgresConnector
 
 
+# ──────────────────────────────────────────────
+#  Helpers
+# ──────────────────────────────────────────────
+
+def make_sync_conn(cursor):
+    mock_conn = MagicMock()
+    mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=cursor)
+    mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
+    return mock_conn
+
+def wire_pool(pg, conn):
+    pg.connection_pool.connection.return_value.__enter__ = MagicMock(return_value=conn)
+    pg.connection_pool.connection.return_value.__exit__ = MagicMock(return_value=False)
+
+
 # ──────────────────────────────────────────────
 #  Sync PostgresConnector
 # ──────────────────────────────────────────────
@@ -76,28 +89,42 @@ class TestPostgresConnectorClose:
 
 
 class TestPostgresConnectorQuery:
-    def test_query_returns_results(self, pg):
-        mock_conn = MagicMock()
-        mock_conn.execute.return_value.fetchall.return_value = [("row1",), ("row2",)]
-        pg.connection_pool.connection.return_value.__enter__ = MagicMock(return_value=mock_conn)
-        pg.connection_pool.connection.return_value.__exit__ = MagicMock(return_value=False)
-        mock_conn.transaction.return_value.__enter__ = MagicMock()
-        mock_conn.transaction.return_value.__exit__ = MagicMock(return_value=False)
+    def test_select_returns_rows(self, pg):
+        cur = MagicMock()
+        cur.description = [("col1",)]
+        cur.fetchall.return_value = [("row1",), ("row2",)]
+        wire_pool(pg, make_sync_conn(cur))
 
         result = pg.query("SELECT 1")
         assert result == [("row1",), ("row2",)]
-        mock_conn.execute.assert_called_once_with("SELECT 1", None)
+        cur.execute.assert_called_once_with("SELECT 1", None)
 
-    def test_query_passes_params(self, pg):
-        mock_conn = MagicMock()
-        mock_conn.execute.return_value.fetchall.return_value = []
-        pg.connection_pool.connection.return_value.__enter__ = MagicMock(return_value=mock_conn)
-        pg.connection_pool.connection.return_value.__exit__ = MagicMock(return_value=False)
-        mock_conn.transaction.return_value.__enter__ = MagicMock()
-        mock_conn.transaction.return_value.__exit__ = MagicMock(return_value=False)
+    def test_select_passes_params(self, pg):
+        cur = MagicMock()
+        cur.description = [("col1",)]
+        cur.fetchall.return_value = []
+        wire_pool(pg, make_sync_conn(cur))
 
         pg.query("SELECT * FROM t WHERE id = %s", (42,))
-        mock_conn.execute.assert_called_once_with("SELECT * FROM t WHERE id = %s", (42,))
+        cur.execute.assert_called_once_with("SELECT * FROM t WHERE id = %s", (42,))
+
+    def test_non_select_returns_none(self, pg):
+        cur = MagicMock()
+        cur.description = None  # INSERT/DDL has no description
+        wire_pool(pg, make_sync_conn(cur))
+
+        result = pg.query("INSERT INTO t VALUES (1)")
+        assert result is None
+        cur.fetchall.assert_not_called()
+
+    def test_select_empty_result_returns_empty_list(self, pg):
+        cur = MagicMock()
+        cur.description = [("col1",)]
+        cur.fetchall.return_value = []
+        wire_pool(pg, make_sync_conn(cur))
+
+        result = pg.query("SELECT 1 WHERE false")
+        assert result == []
 
 
 class TestPostgresConnectorBulkInsert:
@@ -111,12 +138,7 @@ class TestPostgresConnectorBulkInsert:
         mock_cursor.copy.return_value.__enter__ = MagicMock(return_value=mock_copy)
         mock_cursor.copy.return_value.__exit__ = MagicMock(return_value=False)
 
-        mock_conn = MagicMock()
-        mock_conn.cursor.return_value.__enter__ = MagicMock(return_value=mock_cursor)
-        mock_conn.cursor.return_value.__exit__ = MagicMock(return_value=False)
-
-        pg.connection_pool.connection.return_value.__enter__ = MagicMock(return_value=mock_conn)
-        pg.connection_pool.connection.return_value.__exit__ = MagicMock(return_value=False)
+        wire_pool(pg, make_sync_conn(mock_cursor))
 
         data = [{"name": "alice", "age": 30}, {"name": "bob", "age": 25}]
         pg.bulk_insert("users", data)
@@ -196,36 +218,44 @@ class TestAsyncPostgresConnectorContextManager:
 
 
 class TestAsyncPostgresConnectorQuery:
-    @pytest.mark.asyncio
-    async def test_async_query_returns_results(self, async_pg):
-        mock_cursor = AsyncMock()
-        mock_cursor.fetchall.return_value = [("row1",)]
-
+    def _wire(self, async_pg, cur):
         mock_conn = AsyncMock()
-        mock_conn.execute.return_value = mock_cursor
-
+        mock_conn.execute = AsyncMock(return_value=cur)
         async_cm = AsyncMock()
         async_cm.__aenter__.return_value = mock_conn
         async_pg.connection_pool.connection.return_value = async_cm
+        return mock_conn
+
+    @pytest.mark.asyncio
+    async def test_select_returns_rows(self, async_pg):
+        cur = AsyncMock()
+        cur.description = [("col1",)]
+        cur.fetchall = AsyncMock(return_value=[("row1",)])
+        conn = self._wire(async_pg, cur)
 
         result = await async_pg.async_query("SELECT 1")
         assert result == [("row1",)]
-        mock_conn.execute.assert_awaited_once_with("SELECT 1", None)
+        conn.execute.assert_awaited_once_with("SELECT 1", None)
 
     @pytest.mark.asyncio
-    async def test_async_query_passes_params(self, async_pg):
-        mock_cursor = AsyncMock()
-        mock_cursor.fetchall.return_value = []
+    async def test_select_passes_params(self, async_pg):
+        cur = AsyncMock()
+        cur.description = [("col1",)]
+        cur.fetchall = AsyncMock(return_value=[])
+        conn = self._wire(async_pg, cur)
 
-        mock_conn = AsyncMock()
-        mock_conn.execute.return_value = mock_cursor
+        await async_pg.async_query("SELECT * FROM t WHERE id = %s", (1,))
+        conn.execute.assert_awaited_once_with("SELECT * FROM t WHERE id = %s", (1,))
 
-        async_cm = AsyncMock()
-        async_cm.__aenter__.return_value = mock_conn
-        async_pg.connection_pool.connection.return_value = async_cm
+    @pytest.mark.asyncio
+    async def test_non_select_returns_none(self, async_pg):
+        cur = AsyncMock()
+        cur.description = None
+        conn = self._wire(async_pg, cur)
 
-        await async_pg.async_query("SELECT * FROM t WHERE id = %s", (1,))
-        mock_conn.execute.assert_awaited_once_with("SELECT * FROM t WHERE id = %s", (1,))
+        result = await async_pg.async_query("INSERT INTO t VALUES (1)")
+        assert result is None
+        cur.fetchall.assert_not_called()
 
 
 class TestAsyncPostgresConnectorBulkInsert:
@@ -256,4 +286,4 @@ class TestAsyncPostgresConnectorBulkInsert:
         mock_cursor.copy.assert_called_once_with("COPY users (name, age) FROM STDIN")
         assert mock_copy.write_row.await_count == 2
         mock_copy.write_row.assert_any_await(("alice", 30))
-        mock_copy.write_row.assert_any_await(("bob", 25))
+        mock_copy.write_row.assert_any_await(("bob", 25))

pyapiary-2.3.0/src/pyapiary/tests/test_trino/test_unit_trino.py

@@ -0,0 +1,200 @@
+import pytest
+from unittest.mock import MagicMock, patch, call
+from pyapiary.dbms_connectors.trino import TrinoConnector
+
+
+@pytest.fixture
+def mock_connect(mocker):
+    """Patch trino.dbapi.connect and return the mock connection."""
+    mock_conn = MagicMock()
+    mocker.patch("pyapiary.dbms_connectors.trino.connect", return_value=mock_conn)
+    return mock_conn
+
+
+@pytest.fixture
+def connector(mock_connect):
+    """Return a TrinoConnector backed by a mocked connection."""
+    return TrinoConnector(
+        host="localhost",
+        port=8080,
+        user="test_user",
+        catalog="hive",
+        schema="default",
+    )
+
+
+# ---------------------------------------------------------------------------
+# __init__
+# ---------------------------------------------------------------------------
+
+class TestInit:
+    def test_connect_called_with_correct_args(self, mocker):
+        mock_connect = mocker.patch("pyapiary.dbms_connectors.trino.connect")
+        TrinoConnector(host="myhost", port=9090, user="alice", catalog="iceberg", schema="raw")
+        mock_connect.assert_called_once_with(
+            host="myhost",
+            port=9090,
+            user="alice",
+            catalog="iceberg",
+            schema="raw",
+        )
+
+    def test_connect_called_without_optional_args(self, mocker):
+        mock_connect = mocker.patch("pyapiary.dbms_connectors.trino.connect")
+        TrinoConnector(host="myhost", port=9090, user="alice")
+        mock_connect.assert_called_once_with(
+            host="myhost",
+            port=9090,
+            user="alice",
+            catalog=None,
+            schema=None,
+        )
+
+    def test_conn_attribute_set(self, mock_connect, connector):
+        assert connector.conn is mock_connect
+
+
+# ---------------------------------------------------------------------------
+# query()
+# ---------------------------------------------------------------------------
+
+class TestQuery:
+    def test_returns_rows_when_description_present(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_cursor.description = [("col1",), ("col2",)]
+        mock_cursor.fetchall.return_value = [(1, "a"), (2, "b")]
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        result = connector.query("SELECT * FROM foo")
+
+        mock_cursor.execute.assert_called_once_with("SELECT * FROM foo")
+        mock_cursor.fetchall.assert_called_once()
+        assert result == [(1, "a"), (2, "b")]
+
+    def test_returns_none_when_no_description(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_cursor.description = None
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        result = connector.query("CREATE TABLE foo (id INT)")
+
+        mock_cursor.execute.assert_called_once_with("CREATE TABLE foo (id INT)")
+        mock_cursor.fetchall.assert_not_called()
+        assert result is None
+
+    def test_returns_empty_list_for_empty_result_set(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_cursor.description = [("id",)]
+        mock_cursor.fetchall.return_value = []
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        result = connector.query("SELECT * FROM empty_table")
+
+        assert result == []
+
+    def test_cursor_used_as_context_manager(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_cursor.description = None
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        connector.query("SELECT 1")
+
+        mock_connect.cursor.return_value.__enter__.assert_called_once()
+        mock_connect.cursor.return_value.__exit__.assert_called_once()
+
+    def test_propagates_execute_exception(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_cursor.execute.side_effect = RuntimeError("syntax error")
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        with pytest.raises(RuntimeError, match="syntax error"):
+            connector.query("SELECT bad syntax %%")
+
+
+# ---------------------------------------------------------------------------
+# bulk_insert()
+# ---------------------------------------------------------------------------
+
+class TestBulkInsert:
+    def test_inserts_single_row(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        result = connector.bulk_insert("my_table", [{"id": 1, "name": "alice"}])
+
+        expected_query = "INSERT INTO my_table (id, name) VALUES (?, ?)"
+        mock_cursor.executemany.assert_called_once_with(
+            expected_query, [(1, "alice")]
+        )
+        assert result is True
+
+    def test_inserts_multiple_rows(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        data = [
+            {"id": 1, "val": "a"},
+            {"id": 2, "val": "b"},
+            {"id": 3, "val": "c"},
+        ]
+        result = connector.bulk_insert("my_table", data)
+
+        expected_values = [(1, "a"), (2, "b"), (3, "c")]
+        _, call_values = mock_cursor.executemany.call_args
+        # positional args
+        actual_values = mock_cursor.executemany.call_args[0][1]
+        assert actual_values == expected_values
+        assert result is True
+
+    def test_returns_none_for_empty_list(self, mock_connect, connector, capsys):
+        result = connector.bulk_insert("my_table", [])
+
+        assert result is None
+        captured = capsys.readouterr()
+        assert "Invalid" in captured.out
+
+    def test_empty_list_does_not_touch_cursor(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        connector.bulk_insert("my_table", [])
+
+        mock_cursor.executemany.assert_not_called()
+
+    def test_query_string_uses_correct_table_name(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        connector.bulk_insert("schema.target_table", [{"x": 99}])
+
+        actual_query = mock_cursor.executemany.call_args[0][0]
+        assert "schema.target_table" in actual_query
+
+    def test_column_order_matches_first_row_keys(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        data = [{"z": 3, "a": 1, "m": 2}]
+        connector.bulk_insert("t", data)
+
+        actual_query = mock_cursor.executemany.call_args[0][0]
+        # columns in query should match key order of first dict
+        for col in ["z", "a", "m"]:
+            assert col in actual_query
+
+    def test_propagates_executemany_exception(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_cursor.executemany.side_effect = RuntimeError("DB write error")
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        with pytest.raises(RuntimeError, match="DB write error"):
+            connector.bulk_insert("t", [{"id": 1}])
+
+    def test_cursor_used_as_context_manager(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        connector.bulk_insert("t", [{"id": 1}])
+
+        mock_connect.cursor.return_value.__enter__.assert_called_once()
+        mock_connect.cursor.return_value.__exit__.assert_called_once()