pyapiary 2.3.0__tar.gz → 2.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyapiary
-Version: 2.3.0
+Version: 2.3.2
 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

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

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "pyapiary"
 packages = [{ include = "pyapiary", from = "src" }]
-version = "2.3.0"
+version = "2.3.2"
 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"

{pyapiary-2.3.0 → pyapiary-2.3.2}/src/pyapiary/api_connectors/flashpoint.py

@@ -44,6 +44,16 @@ class FlashpointConnector(Broker):
         """
         return self.post("/sources/v2/fraud", json={"query": query, **kwargs})
 
+    @log_method_call
+    def search_fraud_checks(self, query: str, **kwargs) -> httpx.Response:
+        """Checks search provides the ability to search and read data from our Checks dataset.
+
+        Args:
+            query (str): The search string used in the API query.
+            **kwargs: Additional query logic per the Flashpoint API documentation.
+        """
+        return self.post("/sources/v2/fraud/checks", json={"query": query, **kwargs})
+
     @log_method_call
     def search_marketplaces(self, query: str, **kwargs) -> httpx.Response:
         """
@@ -140,6 +150,16 @@ class AsyncFlashpointConnector(AsyncBroker):
         """
         return await self.post("/sources/v2/fraud", json={"query": query, **kwargs})
 
+    @log_method_call
+    async def search_fraud_checks(self, query: str, **kwargs) -> httpx.Response:
+        """Checks search provides the ability to search and read data from our Checks dataset.
+
+        Args:
+            query (str): The search string used in the API query.
+            **kwargs: Additional query logic per the Flashpoint API documentation.
+        """
+        return await self.post("/sources/v2/fraud/checks", json={"query": query, **kwargs})
+
     @log_method_call
     async def search_marketplaces(self, query: str, **kwargs) -> httpx.Response:
         """

{pyapiary-2.3.0 → pyapiary-2.3.2}/src/pyapiary/dbms_connectors/trino.py

@@ -2,13 +2,9 @@ from trino.dbapi import connect
 from typing import List, Dict, Any
 
 class TrinoConnector:
-    def __init__(self, host, port, user, catalog=None, schema=None):
+    def __init__(self, **kwargs):
         self.conn = connect(
-            host=host,
-            port=port,
-            user=user,
-            catalog=catalog,
-            schema=schema
+            **kwargs
         )
     
     def query(self, query_str):

pyapiary-2.3.2/src/pyapiary/tests/test_flashpoint/test_unit_async_flashpoint.py

@@ -0,0 +1,100 @@
+import pytest
+import httpx
+from unittest.mock import patch, AsyncMock
+from pyapiary.api_connectors.flashpoint import AsyncFlashpointConnector
+
+
+@pytest.mark.asyncio
+async def test_async_init_with_api_key():
+    connector = AsyncFlashpointConnector(api_key="test_token")
+    assert connector.api_key == "test_token"
+    assert connector.headers["Authorization"] == "Bearer test_token"
+
+
+@patch.dict("os.environ", {"FLASHPOINT_API_KEY": "env_token"}, clear=True)
+@pytest.mark.asyncio
+async def test_async_init_with_env_key():
+    connector = AsyncFlashpointConnector(load_env_vars=True)
+    assert connector.api_key == "env_token"
+    assert connector.headers["Authorization"] == "Bearer env_token"
+
+
+@pytest.mark.asyncio
+async def test_async_init_missing_key():
+    with patch.dict("os.environ", {}, clear=True):
+        with pytest.raises(ValueError, match="FLASHPOINT_API_KEY is required"):
+            AsyncFlashpointConnector()
+
+
+@patch("pyapiary.api_connectors.flashpoint.AsyncFlashpointConnector.post", new_callable=AsyncMock)
+@pytest.mark.asyncio
+async def test_async_search_fraud_checks(mock_post):
+    import json
+
+    request = httpx.Request("POST", "https://api.flashpoint.io/mock")
+    payload = {"success": True, "data": []}
+    mock_response = httpx.Response(
+        200,
+        request=request,
+        content=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    mock_post.return_value = mock_response
+
+    connector = AsyncFlashpointConnector(api_key="mock_token")
+    result = await connector.search_fraud_checks("stolen checks")
+
+    assert isinstance(result, httpx.Response)
+    assert result.json() == payload
+    mock_post.assert_awaited_once_with(
+        "/sources/v2/fraud/checks", json={"query": "stolen checks"}
+    )
+
+
+@patch("pyapiary.api_connectors.flashpoint.AsyncFlashpointConnector.post", new_callable=AsyncMock)
+@pytest.mark.asyncio
+async def test_async_search_fraud_checks_with_kwargs(mock_post):
+    import json
+
+    request = httpx.Request("POST", "https://api.flashpoint.io/mock")
+    payload = {"success": True, "data": [{"id": "abc123"}]}
+    mock_response = httpx.Response(
+        200,
+        request=request,
+        content=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    mock_post.return_value = mock_response
+
+    connector = AsyncFlashpointConnector(api_key="mock_token")
+    result = await connector.search_fraud_checks("routing number", size=10, from_=0)
+
+    assert isinstance(result, httpx.Response)
+    assert result.json() == payload
+    mock_post.assert_awaited_once_with(
+        "/sources/v2/fraud/checks",
+        json={"query": "routing number", "size": 10, "from_": 0},
+    )
+
+
+@patch("pyapiary.api_connectors.flashpoint.AsyncFlashpointConnector.post", new_callable=AsyncMock)
+@pytest.mark.asyncio
+async def test_async_search_fraud(mock_post):
+    import json
+
+    request = httpx.Request("POST", "https://api.flashpoint.io/mock")
+    payload = {"success": True, "data": []}
+    mock_response = httpx.Response(
+        200,
+        request=request,
+        content=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    mock_post.return_value = mock_response
+
+    connector = AsyncFlashpointConnector(api_key="mock_token")
+    result = await connector.search_fraud("credential stuffing")
+
+    assert isinstance(result, httpx.Response)
+    assert result.json() == payload
+    mock_post.assert_awaited_once()

pyapiary-2.3.2/src/pyapiary/tests/test_flashpoint/test_unit_flashpoint.py

@@ -0,0 +1,94 @@
+import httpx
+import pytest
+from unittest.mock import patch, MagicMock
+from pyapiary.api_connectors.flashpoint import FlashpointConnector
+
+def test_init_with_api_key():
+    connector = FlashpointConnector(api_key="test_token")
+    assert connector.api_key == "test_token"
+    assert connector.headers["Authorization"] == "Bearer test_token"
+
+
+@patch.dict("os.environ", {"FLASHPOINT_API_KEY": "env_token"}, clear=True)
+def test_init_with_env_key():
+    connector = FlashpointConnector(load_env_vars=True)
+    assert connector.api_key == "env_token"
+    assert connector.headers["Authorization"] == "Bearer env_token"
+
+
+def test_init_missing_key():
+    with patch.dict("os.environ", {}, clear=True):
+        with pytest.raises(ValueError, match="FLASHPOINT_API_KEY is required"):
+            FlashpointConnector()
+
+
+@patch("pyapiary.api_connectors.flashpoint.FlashpointConnector.post")
+def test_search_fraud_checks(mock_post):
+    import json
+
+    request = httpx.Request("POST", "https://api.flashpoint.io/mock")
+    payload = {"success": True, "data": []}
+    mock_response = httpx.Response(
+        200,
+        request=request,
+        content=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    mock_post.return_value = mock_response
+
+    connector = FlashpointConnector(api_key="mock_token")
+    result = connector.search_fraud_checks("stolen checks")
+
+    assert isinstance(result, httpx.Response)
+    assert result.json() == payload
+    mock_post.assert_called_once_with(
+        "/sources/v2/fraud/checks", json={"query": "stolen checks"}
+    )
+
+
+@patch("pyapiary.api_connectors.flashpoint.FlashpointConnector.post")
+def test_search_fraud_checks_with_kwargs(mock_post):
+    import json
+
+    request = httpx.Request("POST", "https://api.flashpoint.io/mock")
+    payload = {"success": True, "data": [{"id": "abc123"}]}
+    mock_response = httpx.Response(
+        200,
+        request=request,
+        content=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    mock_post.return_value = mock_response
+
+    connector = FlashpointConnector(api_key="mock_token")
+    result = connector.search_fraud_checks("routing number", size=10, from_=0)
+
+    assert isinstance(result, httpx.Response)
+    assert result.json() == payload
+    mock_post.assert_called_once_with(
+        "/sources/v2/fraud/checks",
+        json={"query": "routing number", "size": 10, "from_": 0},
+    )
+
+
+@patch("pyapiary.api_connectors.flashpoint.FlashpointConnector.post")
+def test_search_fraud(mock_post):
+    import json
+
+    # Use a real httpx.Response so our test matches the new return type
+    request = httpx.Request("POST", "https://api.flashpoint.io/mock")
+    payload = {"success": True, "data": []}
+    mock_response = httpx.Response(
+        200,
+        request=request,
+        content=json.dumps(payload).encode("utf-8"),
+        headers={"Content-Type": "application/json"},
+    )
+    mock_post.return_value = mock_response
+
+    connector = FlashpointConnector(api_key="mock_token")
+    result = connector.search_fraud("credential stuffing")
+
+    assert isinstance(result, httpx.Response)
+    assert result.json() == payload
+    mock_post.assert_called_once()

{pyapiary-2.3.0 → pyapiary-2.3.2}/src/pyapiary/tests/test_trino/test_unit_trino.py

@@ -1,5 +1,5 @@
 import pytest
-from unittest.mock import MagicMock, patch, call
+from unittest.mock import MagicMock, patch
 from pyapiary.dbms_connectors.trino import TrinoConnector
 
 
@@ -15,11 +15,12 @@ def mock_connect(mocker):
 def connector(mock_connect):
     """Return a TrinoConnector backed by a mocked connection."""
     return TrinoConnector(
-        host="localhost",
-        port=8080,
+        host="trino.trashcollector.dev",
+        port=443,
         user="test_user",
         catalog="hive",
         schema="default",
+        http_scheme="https",
     )
 
 
@@ -28,31 +29,33 @@ def connector(mock_connect):
 # ---------------------------------------------------------------------------
 
 class TestInit:
-    def test_connect_called_with_correct_args(self, mocker):
+    def test_connect_called_with_provided_kwargs(self, mocker):
         mock_connect = mocker.patch("pyapiary.dbms_connectors.trino.connect")
-        TrinoConnector(host="myhost", port=9090, user="alice", catalog="iceberg", schema="raw")
+        TrinoConnector(host="myhost", port=443, user="alice", http_scheme="https")
         mock_connect.assert_called_once_with(
             host="myhost",
-            port=9090,
+            port=443,
             user="alice",
-            catalog="iceberg",
-            schema="raw",
+            http_scheme="https",
         )
 
-    def test_connect_called_without_optional_args(self, mocker):
+    def test_connect_called_with_minimal_kwargs(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,
-        )
+        TrinoConnector(host="myhost", port=8080, user="alice")
+        mock_connect.assert_called_once_with(host="myhost", port=8080, user="alice")
 
     def test_conn_attribute_set(self, mock_connect, connector):
         assert connector.conn is mock_connect
 
+    def test_arbitrary_kwargs_forwarded(self, mocker):
+        """Any kwarg the trino client supports should be forwarded as-is."""
+        mock_connect = mocker.patch("pyapiary.dbms_connectors.trino.connect")
+        TrinoConnector(host="h", port=443, user="u", http_scheme="https",
+                       verify=False, session_properties={"query_max_run_time": "1h"})
+        _, call_kwargs = mock_connect.call_args
+        assert call_kwargs["verify"] is False
+        assert call_kwargs["session_properties"] == {"query_max_run_time": "1h"}
+
 
 # ---------------------------------------------------------------------------
 # query()
@@ -108,7 +111,17 @@ class TestQuery:
         mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
 
         with pytest.raises(RuntimeError, match="syntax error"):
-            connector.query("SELECT bad syntax %%")
+            connector.query("SELECT bad %%")
+
+    def test_show_catalogs(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_cursor.description = [("Catalog",)]
+        mock_cursor.fetchall.return_value = [("hive",), ("iceberg",), ("tpch",)]
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        result = connector.query("SHOW CATALOGS")
+
+        assert result == [("hive",), ("iceberg",), ("tpch",)]
 
 
 # ---------------------------------------------------------------------------
@@ -123,27 +136,18 @@ class TestBulkInsert:
         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")]
-        )
+        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"},
-        ]
+        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 actual_values == [(1, "a"), (2, "b"), (3, "c")]
         assert result is True
 
     def test_returns_none_for_empty_list(self, mock_connect, connector, capsys):
@@ -165,10 +169,10 @@ class TestBulkInsert:
         mock_cursor = MagicMock()
         mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
 
-        connector.bulk_insert("schema.target_table", [{"x": 99}])
+        connector.bulk_insert("hive.default.target_table", [{"x": 99}])
 
         actual_query = mock_cursor.executemany.call_args[0][0]
-        assert "schema.target_table" in actual_query
+        assert "hive.default.target_table" in actual_query
 
     def test_column_order_matches_first_row_keys(self, mock_connect, connector):
         mock_cursor = MagicMock()
@@ -178,10 +182,19 @@ class TestBulkInsert:
         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_placeholder_count_matches_column_count(self, mock_connect, connector):
+        mock_cursor = MagicMock()
+        mock_connect.cursor.return_value.__enter__.return_value = mock_cursor
+
+        data = [{"a": 1, "b": 2, "c": 3, "d": 4}]
+        connector.bulk_insert("t", data)
+
+        actual_query = mock_cursor.executemany.call_args[0][0]
+        assert actual_query.count("?") == 4
+
     def test_propagates_executemany_exception(self, mock_connect, connector):
         mock_cursor = MagicMock()
         mock_cursor.executemany.side_effect = RuntimeError("DB write error")

pyapiary-2.3.0/src/pyapiary/tests/test_flashpoint/test_unit_async_flashpoint.py

@@ -1,49 +0,0 @@
-import pytest
-import httpx
-from unittest.mock import patch, AsyncMock
-from pyapiary.api_connectors.flashpoint import AsyncFlashpointConnector
-
-
-@pytest.mark.asyncio
-async def test_async_init_with_api_key():
-    connector = AsyncFlashpointConnector(api_key="test_token")
-    assert connector.api_key == "test_token"
-    assert connector.headers["Authorization"] == "Bearer test_token"
-
-
-@patch.dict("os.environ", {"FLASHPOINT_API_KEY": "env_token"}, clear=True)
-@pytest.mark.asyncio
-async def test_async_init_with_env_key():
-    connector = AsyncFlashpointConnector(load_env_vars=True)
-    assert connector.api_key == "env_token"
-    assert connector.headers["Authorization"] == "Bearer env_token"
-
-
-@pytest.mark.asyncio
-async def test_async_init_missing_key():
-    with patch.dict("os.environ", {}, clear=True):
-        with pytest.raises(ValueError, match="FLASHPOINT_API_KEY is required"):
-            AsyncFlashpointConnector()
-
-
-@patch("pyapiary.api_connectors.flashpoint.AsyncFlashpointConnector.post", new_callable=AsyncMock)
-@pytest.mark.asyncio
-async def test_async_search_fraud(mock_post):
-    import json
-
-    request = httpx.Request("POST", "https://api.flashpoint.io/mock")
-    payload = {"success": True, "data": []}
-    mock_response = httpx.Response(
-        200,
-        request=request,
-        content=json.dumps(payload).encode("utf-8"),
-        headers={"Content-Type": "application/json"},
-    )
-    mock_post.return_value = mock_response
-
-    connector = AsyncFlashpointConnector(api_key="mock_token")
-    result = await connector.search_fraud("credential stuffing")
-
-    assert isinstance(result, httpx.Response)
-    assert result.json() == payload
-    mock_post.assert_awaited_once()

pyapiary-2.3.0/src/pyapiary/tests/test_flashpoint/test_unit_flashpoint.py

@@ -1,45 +0,0 @@
-import httpx
-import pytest
-from unittest.mock import patch, MagicMock
-from pyapiary.api_connectors.flashpoint import FlashpointConnector
-
-def test_init_with_api_key():
-    connector = FlashpointConnector(api_key="test_token")
-    assert connector.api_key == "test_token"
-    assert connector.headers["Authorization"] == "Bearer test_token"
-
-
-@patch.dict("os.environ", {"FLASHPOINT_API_KEY": "env_token"}, clear=True)
-def test_init_with_env_key():
-    connector = FlashpointConnector(load_env_vars=True)
-    assert connector.api_key == "env_token"
-    assert connector.headers["Authorization"] == "Bearer env_token"
-
-
-def test_init_missing_key():
-    with patch.dict("os.environ", {}, clear=True):
-        with pytest.raises(ValueError, match="FLASHPOINT_API_KEY is required"):
-            FlashpointConnector()
-
-
-@patch("pyapiary.api_connectors.flashpoint.FlashpointConnector.post")
-def test_search_fraud(mock_post):
-    import json
-
-    # Use a real httpx.Response so our test matches the new return type
-    request = httpx.Request("POST", "https://api.flashpoint.io/mock")
-    payload = {"success": True, "data": []}
-    mock_response = httpx.Response(
-        200,
-        request=request,
-        content=json.dumps(payload).encode("utf-8"),
-        headers={"Content-Type": "application/json"},
-    )
-    mock_post.return_value = mock_response
-
-    connector = FlashpointConnector(api_key="mock_token")
-    result = connector.search_fraud("credential stuffing")
-
-    assert isinstance(result, httpx.Response)
-    assert result.json() == payload
-    mock_post.assert_called_once()