equity-aggregator 0.1.4__tar.gz → 0.1.6__tar.gz

{equity_aggregator-0.1.4 → equity_aggregator-0.1.6}/.github/workflows/publish-pypi.yml

@@ -77,6 +77,9 @@ jobs:
           sed -i "3s/.*/version = \"$NEW_VERSION\"/" pyproject.toml
           echo "new_version=$NEW_VERSION" >> $GITHUB_OUTPUT
 
+      - name: Update lockfile
+        run: uv lock
+
       - name: Configure git
         run: |
           git config user.name "github-actions[bot]"
@@ -84,7 +87,7 @@ jobs:
 
       - name: Commit and tag version bump
         run: |
-          git add pyproject.toml
+          git add pyproject.toml uv.lock
           git commit -m "chore: bump version to ${{ steps.bump_version.outputs.new_version }} [skip ci]"
           git tag "v${{ steps.bump_version.outputs.new_version }}"
 

{equity_aggregator-0.1.4 → equity_aggregator-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: equity-aggregator
-Version: 0.1.4
+Version: 0.1.6
 Summary: Financial equity data aggregation toolkit
 Project-URL: Homepage, https://github.com/gregorykelleher/equity-aggregator
 Project-URL: Repository, https://github.com/gregorykelleher/equity-aggregator
@@ -45,7 +45,7 @@ Discovery feeds provide raw equity data from primary market sources:
 | 🇺🇸 SEC | United States | Securities and Exchange Commission - US-listed equities |
 | 🇺🇸 Stock Analysis | United States | Stock Analysis - Global equities |
 | 🇺🇸 TradingView | United States | TradingView - US-listed equities |
-| 🇩🇪 XETRA | Germany | Deutsche Börse electronic trading platform - Global listed equities |
+| 🇩🇪 XETRA | International | Deutsche Börse electronic trading platform - Global listed equities |
 
 ### Enrichment Feeds
 

{equity_aggregator-0.1.4 → equity_aggregator-0.1.6}/README.md

@@ -23,7 +23,7 @@ Discovery feeds provide raw equity data from primary market sources:
 | 🇺🇸 SEC | United States | Securities and Exchange Commission - US-listed equities |
 | 🇺🇸 Stock Analysis | United States | Stock Analysis - Global equities |
 | 🇺🇸 TradingView | United States | TradingView - US-listed equities |
-| 🇩🇪 XETRA | Germany | Deutsche Börse electronic trading platform - Global listed equities |
+| 🇩🇪 XETRA | International | Deutsche Börse electronic trading platform - Global listed equities |
 
 ### Enrichment Feeds
 

{equity_aggregator-0.1.4 → equity_aggregator-0.1.6}/pyproject.toml

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

{equity_aggregator-0.1.4 → equity_aggregator-0.1.6}/src/equity_aggregator/README.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-The equity aggregator is a sophisticated financial data processing system that aggregates equity information from multiple discovery sources (LSEG, SEC, Stock Analysis, TradingView, XETRA) and enriches it with supplementary data from Yahoo Finance and Intrinio.
+The equity aggregator is a sophisticated financial data processing system that aggregates equity information from multiple discovery sources (LSEG, SEC, Stock Analysis, TradingView, XETRA and Intrinio) and enriches it with supplementary data from Yahoo Finance and the Global LEI Foundation.
 
 ## Architecture & Design
 
@@ -15,6 +15,7 @@ src/equity_aggregator/
 ├── cli/                    # Presentation Layer - User Interface
 ├── domain/                 # Business Logic Layer - Core Domain
 │   ├── pipeline/           # Aggregation pipeline orchestration
+│   ├── retrieval/          # Canonical equity download and retrieval
 │   └── _utils/             # Domain-specific utilities
 ├── adapters/               # Infrastructure Layer - External Integrations
 │   └── data_sources/       # Data source adapters
@@ -39,7 +40,7 @@ Raw Data Sources → Parse → Convert → Identify → Group → Enrich → Can
 
 Orchestrates parallel data fetching from discovery feeds:
 
-- Fetches data from LSEG, SEC, Stock Analysis, TradingView, and XETRA concurrently
+- Fetches data from LSEG, SEC, Stock Analysis, TradingView, XETRA and Intrinio concurrently
 - Combines all feed data into a single stream for processing
 - Maintains feed source metadata for downstream processing
 
@@ -64,14 +65,13 @@ Standardises financial data to USD reference currency:
 Enriches records with global identification metadata:
 
 - Queries OpenFIGI API for FIGI identifiers
-- Adds CUSIP, ISIN, and other standard identifiers
 - Creates globally unique equity identities
 
 #### 5. **Group**
 
 Groups equities by Share Class FIGI:
 
-- Groups records with identical share_class_figi values
+- Groups records with identical Share Class FIGI values
 - Preserves all discovery feed source data for later merging
 - Each group represents the same equity from multiple discovery sources
 - Yields groups as `list[RawEquity]` for enrichment processing
@@ -80,11 +80,10 @@ Groups equities by Share Class FIGI:
 
 Fetches enrichment data and performs comprehensive single merge:
 
-- Extracts representative identifiers from discovery sources using merge algorithms
-- Queries enrichment feeds (Yahoo Finance, Intrinio) with these identifiers
+- Fetches representative identifiers from discovery data sources
+- Queries enrichment feeds (Yahoo Finance, Global LEI Foundation) using these identifiers
 - Performs single merge of all sources (discovery + enrichment) for optimal data quality
-- Uses same merge logic for identifiers and final merge (mode for IDs, fuzzy clustering for names, frequency for symbols)
-- Applies controlled concurrency to respect API limits
+- Applies controlled concurrency to enrichment feeds to respect API limits
 
 #### 7. **Canonicalise**
 
@@ -102,7 +101,7 @@ The pipeline uses asynchronous operations to process thousands of equity records
 
 **Parallel Data Fetching**
 
-- All discovery feeds (LSEG, SEC, Stock Analysis, TradingView, XETRA) are fetched simultaneously
+- All discovery feeds (LSEG, SEC, Stock Analysis, TradingView, XETRA, Intrinio) are fetched simultaneously
 
 **Streaming Pipeline**
 
@@ -110,7 +109,9 @@ The pipeline uses asynchronous operations to process thousands of equity records
 
 **Controlled Concurrency**
 
-- External API calls (OpenFIGI, Yahoo Finance, Intrinio) use semaphores to limit concurrent requests and respect rate limits
+- External API calls (OpenFIGI, Yahoo Finance, GLEIF) use semaphores to limit concurrent requests and respect rate limits
+- Each enrichment feed has a configurable concurrency limit
+- Fetch operations include timeout protection to prevent indefinite blocking
 
 **Non-blocking Operations**
 
@@ -145,11 +146,14 @@ schemas/
 ├── raw.py                    # RawEquity - intermediate pipeline format
 ├── canonical.py              # CanonicalEquity - final standardised format
 ├── types.py                  # Type definitions and validators
+├── validators.py             # Reusable validators for identifiers and financial data
 └── feeds/                    # Feed-specific data models
     ├── lseg_feed_data.py
     ├── sec_feed_data.py
     ├── stock_analysis_feed_data.py
     ├── tradingview_feed_data.py
+    ├── gleif_feed_data.py
+    ├── feed_validators.py
     ├── xetra_feed_data.py
     ├── yfinance_feed_data.py
     └── intrinio_feed_data.py
@@ -158,6 +162,7 @@ schemas/
 ### Critical Role of Schemas
 
 #### 1. **Data Validation at Boundaries**
+
 Each feed has a dedicated Pydantic schema that:
 - Validates incoming data structure and types
 - Normalises field names and formats
@@ -204,6 +209,7 @@ class LsegFeedData(BaseModel):
 - **Stock Analysis**: US equities with comprehensive financial metrics
 - **TradingView**: US equities with comprehensive financial metrics
 - **XETRA**: Deutsche Börse Stock Exchange
+- **Intrinio**: US financial data API providing company, securities, and real-time quote data
 
 **Characteristics**:
 
@@ -213,12 +219,12 @@ class LsegFeedData(BaseModel):
 ### Enrichment Feeds (Supplementary Sources)
 
 - **Yahoo Finance**: Market data and financial metrics
-- **Intrinio**: Market data and financial metrics
+- **Global LEI Foundation**: ISIN->LEI mapping for Legal Entity Identifier enrichment
 
 **Characteristics**
 
 - Provides additional financial metrics (market cap, analyst ratings, etc.)
-- Uses representative identifiers from discovery sources for lookup
+- Uses representative identifiers from discovery sources for look-up
 - Applied after grouping but before final merge
 
 ## Equity Aggregator Components

{equity_aggregator-0.1.4 → equity_aggregator-0.1.6}/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.6/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.6/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.6/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.6/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.6/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