equity-aggregator 0.1.5__tar.gz → 0.1.7__tar.gz

{equity_aggregator-0.1.5 → equity_aggregator-0.1.7}/.github/workflows/publish-build-release.yml

@@ -40,7 +40,11 @@ jobs:
 
       - name: Create .env file
         run: |
-          printf '%b' "${{ secrets.EQUITY_AGGREGATOR_SECRETS }}" > .env
+          cat <<EOF > .env
+          EXCHANGE_RATE_API_KEY=${{ secrets.EXCHANGE_RATE_API_KEY }}
+          INTRINIO_API_KEY=${{ secrets.INTRINIO_API_KEY }}
+          OPENFIGI_API_KEY=${{ secrets.OPENFIGI_API_KEY }}
+          EOF
           chmod 600 .env
           test -s .env || { echo "::error ::empty .env"; exit 1; }
 

{equity_aggregator-0.1.5 → equity_aggregator-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: equity-aggregator
-Version: 0.1.5
+Version: 0.1.7
 Summary: Financial equity data aggregation toolkit
 Project-URL: Homepage, https://github.com/gregorykelleher/equity-aggregator
 Project-URL: Repository, https://github.com/gregorykelleher/equity-aggregator

{equity_aggregator-0.1.5 → equity_aggregator-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "equity-aggregator"
-version = "0.1.5"
+version = "0.1.7"
 description = "Financial equity data aggregation toolkit"
 readme = "README.md"
 license = "MIT"

{equity_aggregator-0.1.5 → equity_aggregator-0.1.7}/tests/live/adapters/data_sources/discovery_feeds/intrinio/test_intrinio.py

@@ -29,38 +29,28 @@ def _get_api_key() -> str:
     return os.getenv("INTRINIO_API_KEY", "")
 
 
-async def test_intrinio_endpoint_returns_ok() -> None:
+@pytest.fixture(scope="module")
+def intrinio_companies_response() -> httpx.Response:
     """
-    ARRANGE: live Intrinio companies API endpoint
-    ACT:     send GET request
-    ASSERT:  returns HTTP 200
+    Fetch Intrinio companies API response once and share across all tests.
     """
     params = {"api_key": _get_api_key(), "page_size": "10"}
+    with httpx.Client() as client:
+        return client.get(_INTRINIO_COMPANIES_URL, params=params)
 
-    async with httpx.AsyncClient() as client:
-        response = await client.get(_INTRINIO_COMPANIES_URL, params=params)
-
-    assert response.status_code == _HTTP_OK
 
-
-async def test_intrinio_record_validates_against_schema() -> None:
+@pytest.fixture(scope="module")
+def intrinio_security_record(intrinio_companies_response: httpx.Response) -> dict:
     """
-    ARRANGE: security record from live Intrinio API response
-    ACT:     validate with IntrinioFeedData schema
-    ASSERT:  no ValidationError raised
+    Fetch a security record from Intrinio for schema validation.
     """
-    params = {"api_key": _get_api_key(), "page_size": "10"}
-
-    async with httpx.AsyncClient() as client:
-        response = await client.get(_INTRINIO_COMPANIES_URL, params=params)
-
-    records, _ = parse_companies_response(response.json())
+    records, _ = parse_companies_response(intrinio_companies_response.json())
     first_company = records[0]
     ticker = first_company["company_ticker"]
     securities_url = f"{_INTRINIO_COMPANIES_URL}/{ticker}/securities"
 
-    async with httpx.AsyncClient() as client:
-        securities_response = await client.get(
+    with httpx.Client() as client:
+        securities_response = client.get(
             securities_url,
             params={"api_key": _get_api_key()},
         )
@@ -70,4 +60,26 @@ async def test_intrinio_record_validates_against_schema() -> None:
     if not security_records:
         pytest.skip("No securities found for first company")
 
-    assert IntrinioFeedData.model_validate(security_records[0])
+    return security_records[0]
+
+
+def test_intrinio_endpoint_returns_ok(
+    intrinio_companies_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live Intrinio companies API endpoint
+    ACT:     send GET request
+    ASSERT:  returns HTTP 200
+    """
+    assert intrinio_companies_response.status_code == _HTTP_OK
+
+
+def test_intrinio_record_validates_against_schema(
+    intrinio_security_record: dict,
+) -> None:
+    """
+    ARRANGE: security record from live Intrinio API response
+    ACT:     validate with IntrinioFeedData schema
+    ASSERT:  no ValidationError raised
+    """
+    assert IntrinioFeedData.model_validate(intrinio_security_record)

equity_aggregator-0.1.7/tests/live/adapters/data_sources/discovery_feeds/lseg/test_lseg.py

@@ -0,0 +1,89 @@
+# lseg/test_lseg.py
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from equity_aggregator.adapters.data_sources.discovery_feeds.lseg._utils import (
+    parse_response,
+)
+from equity_aggregator.adapters.data_sources.discovery_feeds.lseg.lseg import (
+    _HEADERS,
+    _LSEG_BASE_PARAMS,
+    _LSEG_PATH,
+    _LSEG_SEARCH_URL,
+)
+from equity_aggregator.schemas.feeds import LsegFeedData
+
+pytestmark = pytest.mark.live
+
+_HTTP_OK = 200
+_TIMEOUT = httpx.Timeout(connect=10.0, read=60.0, write=10.0, pool=None)
+
+
+@pytest.fixture(scope="module")
+def lseg_response() -> httpx.Response:
+    """
+    Fetch LSEG API response once and share across all tests in this module.
+    """
+    with httpx.Client(headers=_HEADERS, timeout=_TIMEOUT) as client:
+        return client.get(
+            _LSEG_SEARCH_URL,
+            params={
+                "path": _LSEG_PATH,
+                "parameters": f"{_LSEG_BASE_PARAMS}&page=0",
+            },
+        )
+
+
+def test_lseg_endpoint_returns_ok(lseg_response: httpx.Response) -> None:
+    """
+    ARRANGE: live LSEG API endpoint
+    ACT:     send GET request
+    ASSERT:  returns HTTP 200
+    """
+    assert lseg_response.status_code == _HTTP_OK
+
+
+def test_lseg_response_contains_components_key(lseg_response: httpx.Response) -> None:
+    """
+    ARRANGE: live LSEG API response
+    ACT:     parse JSON payload
+    ASSERT:  contains 'components' key
+    """
+    payload = lseg_response.json()
+
+    assert "components" in payload
+
+
+def test_lseg_response_parses_to_non_empty_records(
+    lseg_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live LSEG API response
+    ACT:     parse response using parse_response
+    ASSERT:  returns non-empty list of records
+    """
+    payload = lseg_response.json()
+    records, _ = parse_response(payload)
+
+    assert isinstance(records, list) and len(records) > 0
+
+
+def test_lseg_record_validates_against_schema(lseg_response: httpx.Response) -> None:
+    """
+    ARRANGE: first record from live LSEG API response
+    ACT:     validate with LsegFeedData schema
+    ASSERT:  no ValidationError raised
+    """
+    payload = lseg_response.json()
+    records, _ = parse_response(payload)
+    first_record = records[0]
+
+    try:
+        LsegFeedData.model_validate(first_record)
+        validated = True
+    except ValidationError:
+        validated = False
+
+    assert validated

equity_aggregator-0.1.7/tests/live/adapters/data_sources/discovery_feeds/sec/test_sec.py

@@ -0,0 +1,76 @@
+# sec/test_sec.py
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from equity_aggregator.adapters.data_sources.discovery_feeds.sec.sec import (
+    _HEADERS,
+    _SEC_SEARCH_URL,
+    _parse_row,
+)
+from equity_aggregator.schemas.feeds import SecFeedData
+
+pytestmark = pytest.mark.live
+
+_HTTP_OK = 200
+
+
+@pytest.fixture(scope="module")
+def sec_response() -> httpx.Response:
+    """
+    Fetch SEC API response once and share across all tests in this module.
+    """
+    with httpx.Client(headers=_HEADERS) as client:
+        return client.get(_SEC_SEARCH_URL)
+
+
+def test_sec_endpoint_returns_ok(sec_response: httpx.Response) -> None:
+    """
+    ARRANGE: live SEC API endpoint
+    ACT:     send GET request
+    ASSERT:  returns HTTP 200
+    """
+    assert sec_response.status_code == _HTTP_OK
+
+
+def test_sec_response_contains_data_key(sec_response: httpx.Response) -> None:
+    """
+    ARRANGE: live SEC API response
+    ACT:     parse JSON payload
+    ASSERT:  contains 'data' key
+    """
+    payload = sec_response.json()
+
+    assert "data" in payload
+
+
+def test_sec_response_data_is_non_empty_list(sec_response: httpx.Response) -> None:
+    """
+    ARRANGE: live SEC API response
+    ACT:     extract 'data' field
+    ASSERT:  is a non-empty list
+    """
+    payload = sec_response.json()
+    data = payload.get("data", [])
+
+    assert isinstance(data, list) and len(data) > 0
+
+
+def test_sec_record_validates_against_schema(sec_response: httpx.Response) -> None:
+    """
+    ARRANGE: first row from live SEC API response, parsed into record
+    ACT:     validate with SecFeedData schema
+    ASSERT:  no ValidationError raised
+    """
+    payload = sec_response.json()
+    first_row = payload["data"][0]
+    record = _parse_row(first_row)
+
+    try:
+        SecFeedData.model_validate(record)
+        validated = True
+    except ValidationError:
+        validated = False
+
+    assert validated

equity_aggregator-0.1.7/tests/live/adapters/data_sources/discovery_feeds/stock_analysis/test_stock_analysis.py

@@ -0,0 +1,87 @@
+# stock_analysis/test_stock_analysis.py
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from equity_aggregator.adapters.data_sources.discovery_feeds.stock_analysis import (
+    stock_analysis,
+)
+from equity_aggregator.schemas.feeds import StockAnalysisFeedData
+
+pytestmark = pytest.mark.live
+
+_HTTP_OK = 200
+
+
+@pytest.fixture(scope="module")
+def stock_analysis_response() -> httpx.Response:
+    """
+    Fetch Stock Analysis API response once and share across all tests in this module.
+    """
+    with httpx.Client() as client:
+        return client.get(
+            stock_analysis._STOCK_ANALYSIS_SEARCH_URL,
+            params=stock_analysis._PARAMS,
+        )
+
+
+def test_stock_analysis_endpoint_returns_ok(
+    stock_analysis_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live Stock Analysis screener API endpoint
+    ACT:     send GET request
+    ASSERT:  returns HTTP 200
+    """
+    assert stock_analysis_response.status_code == _HTTP_OK
+
+
+def test_stock_analysis_response_contains_data_key(
+    stock_analysis_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live Stock Analysis API response
+    ACT:     parse JSON payload
+    ASSERT:  contains 'data' key
+    """
+    payload = stock_analysis_response.json()
+
+    assert "data" in payload
+
+
+def test_stock_analysis_response_data_is_non_empty_list(
+    stock_analysis_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live Stock Analysis API response
+    ACT:     extract nested data array
+    ASSERT:  is a non-empty list
+    """
+    payload = stock_analysis_response.json()
+    data_wrapper = payload.get("data", {})
+    records = data_wrapper.get("data", [])
+
+    assert isinstance(records, list) and len(records) > 0
+
+
+def test_stock_analysis_record_validates_against_schema(
+    stock_analysis_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: first record from live Stock Analysis API response
+    ACT:     validate with StockAnalysisFeedData schema
+    ASSERT:  no ValidationError raised
+    """
+    payload = stock_analysis_response.json()
+    data_wrapper = payload.get("data", {})
+    records = data_wrapper.get("data", [])
+    first_record = records[0]
+
+    try:
+        StockAnalysisFeedData.model_validate(first_record)
+        validated = True
+    except ValidationError:
+        validated = False
+
+    assert validated

equity_aggregator-0.1.7/tests/live/adapters/data_sources/discovery_feeds/tradingview/test_tradingview.py

@@ -0,0 +1,90 @@
+# tradingview/test_tradingview.py
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from equity_aggregator.adapters.data_sources.discovery_feeds.tradingview import (
+    tradingview,
+)
+from equity_aggregator.schemas.feeds import TradingViewFeedData
+
+pytestmark = pytest.mark.live
+
+_HTTP_OK = 200
+
+
+def _build_request_body(start: int = 0, end: int = tradingview._PAGE_SIZE) -> dict:
+    """
+    Build request body with pagination range.
+    """
+    return {**tradingview._REQUEST_BODY_TEMPLATE, "range": [start, end]}
+
+
+@pytest.fixture(scope="module")
+def tradingview_response() -> httpx.Response:
+    """
+    Fetch TradingView API response once and share across all tests in this module.
+    """
+    with httpx.Client() as client:
+        return client.post(
+            tradingview._TRADINGVIEW_SCAN_URL,
+            json=_build_request_body(),
+        )
+
+
+def test_tradingview_endpoint_returns_ok(tradingview_response: httpx.Response) -> None:
+    """
+    ARRANGE: live TradingView scanner API endpoint
+    ACT:     send POST request
+    ASSERT:  returns HTTP 200
+    """
+    assert tradingview_response.status_code == _HTTP_OK
+
+
+def test_tradingview_response_contains_data_key(
+    tradingview_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live TradingView API response
+    ACT:     parse JSON payload
+    ASSERT:  contains 'data' key
+    """
+    payload = tradingview_response.json()
+
+    assert "data" in payload
+
+
+def test_tradingview_response_data_is_non_empty_list(
+    tradingview_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live TradingView API response
+    ACT:     extract 'data' field
+    ASSERT:  is a non-empty list
+    """
+    payload = tradingview_response.json()
+    data = payload.get("data", [])
+
+    assert isinstance(data, list) and len(data) > 0
+
+
+def test_tradingview_record_validates_against_schema(
+    tradingview_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: first parsed record from live TradingView API response
+    ACT:     validate with TradingViewFeedData schema
+    ASSERT:  no ValidationError raised
+    """
+    payload = tradingview_response.json()
+    first_row = payload["data"][0]
+    record = tradingview._parse_row(first_row)
+
+    try:
+        TradingViewFeedData.model_validate(record)
+        validated = True
+    except ValidationError:
+        validated = False
+
+    assert validated

equity_aggregator-0.1.7/tests/live/adapters/data_sources/discovery_feeds/xetra/test_xetra.py

@@ -0,0 +1,79 @@
+# xetra/test_xetra.py
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from equity_aggregator.adapters.data_sources.discovery_feeds.xetra.xetra import (
+    _HEADERS,
+    _XETRA_SEARCH_URL,
+    _build_payload,
+    _extract_records,
+)
+from equity_aggregator.schemas.feeds import XetraFeedData
+
+pytestmark = pytest.mark.live
+
+_HTTP_OK = 200
+
+
+@pytest.fixture(scope="module")
+def xetra_response() -> httpx.Response:
+    """
+    Fetch XETRA API response once and share across all tests in this module.
+    """
+    with httpx.Client(headers=_HEADERS) as client:
+        return client.post(_XETRA_SEARCH_URL, json=_build_payload(offset=0))
+
+
+def test_xetra_endpoint_returns_ok(xetra_response: httpx.Response) -> None:
+    """
+    ARRANGE: live XETRA API endpoint
+    ACT:     send POST request
+    ASSERT:  returns HTTP 200
+    """
+    assert xetra_response.status_code == _HTTP_OK
+
+
+def test_xetra_response_contains_data_key(xetra_response: httpx.Response) -> None:
+    """
+    ARRANGE: live XETRA API response
+    ACT:     parse JSON payload
+    ASSERT:  contains 'data' key
+    """
+    payload = xetra_response.json()
+
+    assert "data" in payload
+
+
+def test_xetra_response_data_is_non_empty_list(xetra_response: httpx.Response) -> None:
+    """
+    ARRANGE: live XETRA API response
+    ACT:     extract 'data' field
+    ASSERT:  is a non-empty list
+    """
+    payload = xetra_response.json()
+    data = payload.get("data", [])
+
+    assert isinstance(data, list) and len(data) > 0
+
+
+def test_xetra_extracted_record_validates_against_schema(
+    xetra_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: first extracted record from live XETRA API response
+    ACT:     validate with XetraFeedData schema
+    ASSERT:  no ValidationError raised
+    """
+    payload = xetra_response.json()
+    records = _extract_records(payload)
+    first_record = records[0]
+
+    try:
+        XetraFeedData.model_validate(first_record)
+        validated = True
+    except ValidationError:
+        validated = False
+
+    assert validated

equity_aggregator-0.1.7/tests/live/adapters/data_sources/enrichment_feeds/gleif/test_gleif.py

@@ -0,0 +1,81 @@
+# gleif/test_gleif.py
+
+import httpx
+import pytest
+
+from equity_aggregator.adapters.data_sources.enrichment_feeds.gleif.api import (
+    GLEIF_ISIN_LEI_URL,
+)
+
+pytestmark = pytest.mark.live
+
+_HTTP_OK = 200
+
+
+@pytest.fixture(scope="module")
+def gleif_response() -> httpx.Response:
+    """
+    Fetch GLEIF API response once and share across all tests in this module.
+    """
+    with httpx.Client() as client:
+        return client.get(GLEIF_ISIN_LEI_URL)
+
+
+def test_gleif_api_endpoint_returns_ok(gleif_response: httpx.Response) -> None:
+    """
+    ARRANGE: live GLEIF ISIN-LEI mapping API endpoint
+    ACT:     send GET request
+    ASSERT:  returns HTTP 200
+    """
+    assert gleif_response.status_code == _HTTP_OK
+
+
+def test_gleif_api_response_contains_data_key(gleif_response: httpx.Response) -> None:
+    """
+    ARRANGE: live GLEIF API response
+    ACT:     parse JSON payload
+    ASSERT:  contains 'data' key
+    """
+    payload = gleif_response.json()
+
+    assert "data" in payload
+
+
+def test_gleif_api_response_data_contains_attributes(
+    gleif_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live GLEIF API response
+    ACT:     extract 'data' field
+    ASSERT:  contains 'attributes' key
+    """
+    payload = gleif_response.json()
+    data = payload.get("data", {})
+
+    assert "attributes" in data
+
+
+def test_gleif_api_response_contains_download_link(
+    gleif_response: httpx.Response,
+) -> None:
+    """
+    ARRANGE: live GLEIF API response
+    ACT:     extract attributes from response
+    ASSERT:  contains 'downloadLink' key
+    """
+    payload = gleif_response.json()
+    attrs = payload.get("data", {}).get("attributes", {})
+
+    assert "downloadLink" in attrs
+
+
+def test_gleif_api_download_link_is_valid_url(gleif_response: httpx.Response) -> None:
+    """
+    ARRANGE: live GLEIF API response
+    ACT:     extract download link
+    ASSERT:  is a non-empty string starting with https
+    """
+    payload = gleif_response.json()
+    download_link = payload.get("data", {}).get("attributes", {}).get("downloadLink")
+
+    assert isinstance(download_link, str) and download_link.startswith("https://")