boarddata 6.4.2__tar.gz → 6.6.1__tar.gz

{boarddata-6.4.2 → boarddata-6.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boarddata
-Version: 6.4.2
+Version: 6.6.1
 Summary: Python SDK for the BoardData V2 REST API
 License: MIT
 Classifier: Development Status :: 4 - Beta

{boarddata-6.4.2 → boarddata-6.6.1}/__init__.py

@@ -6,7 +6,7 @@ from .cache import FileTokenCache, ScalewaySecretTokenCache
 from .client import BoardDataClient
 from .errors import BoardDataError, ExportTooLargeError
 
-__version__ = "6.4.2"
+__version__ = "6.6.1"
 __all__ = [
     "Base",
     "BoardDataClient",

{boarddata-6.4.2 → boarddata-6.6.1}/_comex.py

@@ -455,6 +455,155 @@ class ComexMixin:
         )
         return self._post(f"comex/{comex_uid}/compensations/", payload)  # type: ignore[attr-defined]
 
+    def replace_comex_compensation(
+        self,
+        comex_uid: str,
+        fiscal_year: int,
+        nature: str,
+        *,
+        assembly: str | None = None,
+        fixed: str | None = None,
+        variable: str | None = None,
+        exceptional: str | None = None,
+        benefits_in_kind: str | None = None,
+        stock_options: str | None = None,
+        performance_shares: str | None = None,
+        other_long_term: str | None = None,
+        retirement_benefit: str | None = None,
+        retirement_contribution: str | None = None,
+        severance: str | None = None,
+        golden_hello: str | None = None,
+        fixed_paid: str | None = None,
+        variable_paid: str | None = None,
+        exceptional_paid: str | None = None,
+        benefits_in_kind_paid: str | None = None,
+        stock_options_paid: str | None = None,
+        performance_shares_paid: str | None = None,
+        other_long_term_paid: str | None = None,
+        severance_paid: str | None = None,
+        retirement_benefit_paid: str | None = None,
+        retirement_contribution_paid: str | None = None,
+        golden_hello_paid: str | None = None,
+        exercised_options: str | None = None,
+        performance_shares_number: int | None = None,
+        pay_ratio_average: str | None = None,
+        pay_ratio_median: str | None = None,
+        pay_ratio_method: str | None = None,
+        non_compete_compensation: str | None = None,
+        non_compete: bool | None = None,
+        clawback: bool | None = None,
+        unemployment_insurance: bool | None = None,
+        holding: bool | None = None,
+        has_employment_contract: bool | None = None,
+        discretionary_grant: bool | None = None,
+        subsidiary_remuneration: str | None = None,
+        remuneration_via_holding: bool | None = None,
+        currency: str | None = None,
+        field_sources: list[FieldSourcePayload] | None = None,
+        criteria: list[dict[str, Any]] | None = None,
+        component_achievement_rates: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        """Replace (clean-swap) a compensation entry for a comex mandate.
+
+        Args:
+            comex_uid: Comex mandate UUID.
+            fiscal_year: Fiscal year.
+            nature: Compensation nature (``"REAL"`` or ``"POLITIC"``).
+            assembly: Assembly UUID.
+            fixed: Fixed compensation (decimal).
+            variable: Variable compensation (decimal).
+            exceptional: Exceptional compensation (decimal).
+            benefits_in_kind: Benefits in kind (decimal).
+            stock_options: Stock options value (decimal).
+            performance_shares: Performance shares value (decimal).
+            other_long_term: Other long-term compensation (decimal).
+            retirement_benefit: Retirement benefit (decimal).
+            retirement_contribution: Retirement contribution (decimal).
+            severance: Severance (decimal).
+            golden_hello: Golden hello (decimal).
+            fixed_paid: Fixed paid (decimal).
+            variable_paid: Variable paid (decimal).
+            exceptional_paid: Exceptional paid (decimal).
+            benefits_in_kind_paid: Benefits in kind paid (decimal).
+            stock_options_paid: Stock options paid (decimal).
+            performance_shares_paid: Performance shares paid (decimal).
+            other_long_term_paid: Other long-term paid (decimal).
+            severance_paid: Severance paid (decimal).
+            retirement_benefit_paid: Retirement benefit paid (decimal).
+            retirement_contribution_paid: Retirement contribution paid (decimal).
+            golden_hello_paid: Golden hello paid (decimal).
+            exercised_options: Exercised options value (decimal).
+            performance_shares_number: Number of performance shares.
+            pay_ratio_average: Average pay ratio (decimal).
+            pay_ratio_median: Median pay ratio (decimal).
+            pay_ratio_method: Pay ratio calculation method.
+            non_compete_compensation: Non-compete compensation (decimal).
+            non_compete: Whether non-compete clause applies.
+            clawback: Whether clawback clause applies.
+            unemployment_insurance: Whether unemployment insurance applies.
+            holding: Whether holding applies.
+            has_employment_contract: Whether has employment contract.
+            discretionary_grant: Whether discretionary grant applies.
+            subsidiary_remuneration: Subsidiary remuneration (decimal).
+            remuneration_via_holding: Whether remuneration is provided via holding.
+            currency: Currency code (e.g. ``"EUR"``).
+            field_sources: Document provenance for fields.
+            criteria: List of compensation criteria dicts.
+            component_achievement_rates: List of achievement rate dicts.
+
+        Returns:
+            dict with {"id", "action"} where action is "replaced" (a prior live row existed) or "created" (none existed).
+
+        Raises:
+            BoardDataError: On non-2xx API response.
+        """
+        payload = self._build_payload(  # type: ignore[attr-defined]
+            fiscal_year=fiscal_year,
+            nature=nature,
+            assembly=assembly,
+            fixed=fixed,
+            variable=variable,
+            exceptional=exceptional,
+            benefits_in_kind=benefits_in_kind,
+            stock_options=stock_options,
+            performance_shares=performance_shares,
+            other_long_term=other_long_term,
+            retirement_benefit=retirement_benefit,
+            retirement_contribution=retirement_contribution,
+            severance=severance,
+            golden_hello=golden_hello,
+            fixed_paid=fixed_paid,
+            variable_paid=variable_paid,
+            exceptional_paid=exceptional_paid,
+            benefits_in_kind_paid=benefits_in_kind_paid,
+            stock_options_paid=stock_options_paid,
+            performance_shares_paid=performance_shares_paid,
+            other_long_term_paid=other_long_term_paid,
+            severance_paid=severance_paid,
+            retirement_benefit_paid=retirement_benefit_paid,
+            retirement_contribution_paid=retirement_contribution_paid,
+            golden_hello_paid=golden_hello_paid,
+            exercised_options=exercised_options,
+            performance_shares_number=performance_shares_number,
+            pay_ratio_average=pay_ratio_average,
+            pay_ratio_median=pay_ratio_median,
+            pay_ratio_method=pay_ratio_method,
+            non_compete_compensation=non_compete_compensation,
+            non_compete=non_compete,
+            clawback=clawback,
+            unemployment_insurance=unemployment_insurance,
+            holding=holding,
+            has_employment_contract=has_employment_contract,
+            discretionary_grant=discretionary_grant,
+            subsidiary_remuneration=subsidiary_remuneration,
+            remuneration_via_holding=remuneration_via_holding,
+            currency=currency,
+            field_sources=field_sources,
+            criteria=criteria,
+            component_achievement_rates=component_achievement_rates,
+        )
+        return self._post(f"comex/{comex_uid}/compensations/replace/", payload)  # type: ignore[attr-defined]
+
     def update_comex_compensation(
         self,
         comex_uid: str,

boarddata-6.6.1/_risks.py

@@ -0,0 +1,35 @@
+"""Risk-Factors (Art. 16) methods."""
+
+from __future__ import annotations
+
+from .types.risks import RiskSectionBatchItemPayload, RiskSectionBatchResultItem
+
+
+class RisksMixin:
+    """Risk-Factors API methods (Art. 16 'Risk Factors' disclosure)."""
+
+    def batch_create_risk_section(
+        self,
+        sections: list[RiskSectionBatchItemPayload],
+    ) -> list[RiskSectionBatchResultItem]:
+        """Batch upsert risk sections.
+
+        Each item is matched by the natural key ``(company, date_publication)``,
+        where ``company`` is the issuer ISIN; the backend does a delete-and-replace
+        of the section's categories and factors. A ``section_found: false`` envelope
+        is accepted (it records the negative finding).
+
+        Args:
+            sections: List of risk-section envelopes
+                (``company``, ``date_publication``, ``_risk_section``,
+                ``_risk_categories``, ``_risk_factor_items``).
+
+        Returns:
+            One result per item, each with ``company`` and ``action``
+            (``"loaded"`` / ``"skipped_unknown_company"`` / ``"error"``); a loaded
+            section also carries ``section_id`` and ``factor_count``.
+
+        Raises:
+            BoardDataError: On non-2xx API response.
+        """
+        return self._post("risks/batch/", sections)  # type: ignore[attr-defined]

{boarddata-6.4.2 → boarddata-6.6.1}/boarddata.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boarddata
-Version: 6.4.2
+Version: 6.6.1
 Summary: Python SDK for the BoardData V2 REST API
 License: MIT
 Classifier: Development Status :: 4 - Beta

{boarddata-6.4.2 → boarddata-6.6.1}/boarddata.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ _documents.py
 _esg.py
 _indexes.py
 _persons.py
+_risks.py
 _sentinel.py
 _utilities.py
 cache.py
@@ -32,6 +33,7 @@ pyproject.toml
 ./_esg.py
 ./_indexes.py
 ./_persons.py
+./_risks.py
 ./_sentinel.py
 ./_utilities.py
 ./cache.py
@@ -60,6 +62,7 @@ tests/test_esg.py
 tests/test_exports.py
 tests/test_indexes.py
 tests/test_persons.py
+tests/test_risks.py
 tests/test_sentinel.py
 tests/test_utilities.py
 types/__init__.py
@@ -74,4 +77,5 @@ types/documents.py
 types/esg.py
 types/indexes.py
 types/persons.py
+types/risks.py
 types/sentinel.py

{boarddata-6.4.2 → boarddata-6.6.1}/client.py

@@ -13,6 +13,7 @@ from ._documents import DocumentMixin
 from ._esg import ESGMixin
 from ._indexes import IndexMixin
 from ._persons import PersonMixin
+from ._risks import RisksMixin
 from ._sentinel import SentinelMixin
 from ._utilities import UtilitiesMixin
 
@@ -26,6 +27,7 @@ class BoardDataClient(
     DocumentMixin,
     AssemblyMixin,
     ESGMixin,
+    RisksMixin,
     SentinelMixin,
     CriteriaMixin,
     IndexMixin,

{boarddata-6.4.2 → boarddata-6.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "boarddata"
-version = "6.4.2"
+version = "6.6.1"
 description = "Python SDK for the BoardData V2 REST API"
 readme = "README.md"
 license = {text = "MIT"}

{boarddata-6.4.2 → boarddata-6.6.1}/tests/test_comex.py

@@ -128,3 +128,34 @@ class TestListBulkComexCompensations:
         c.list_bulk_comex_compensations(company="uuid1", fiscal_year=2024)
         args, kwargs = c._request.call_args
         assert args == ("GET", "comex/compensations/")
+
+
+class TestReplaceComexCompensation:
+    def test_posts_to_replace_url_with_explicit_fields(self):
+        c = make_client()
+        c._request.return_value = {"id": "comp9", "action": "replaced"}
+        result = c.replace_comex_compensation(
+            "comex-uuid",
+            2024,
+            "REAL",
+            fixed="500000.00",
+            variable="200000.00",
+            currency="EUR",
+        )
+        # Exactly one HTTP call, and it must POST to the /replace/ tail.
+        assert c._request.call_count == 1
+        args, kwargs = c._request.call_args
+        assert args == ("POST", "comex/comex-uuid/compensations/replace/")
+        payload = kwargs["json"]
+        assert payload["fixed"] == "500000.00"
+        assert payload["variable"] == "200000.00"
+        assert payload["currency"] == "EUR"
+        assert payload["fiscal_year"] == 2024
+        assert payload["nature"] == "REAL"
+        assert result == {"id": "comp9", "action": "replaced"}
+
+    def test_returns_created_when_no_prior_row(self):
+        c = make_client()
+        c._request.return_value = {"id": "comp10", "action": "created"}
+        result = c.replace_comex_compensation("comex-uuid", 2024, "POLITIC", fixed="1.00")
+        assert result["action"] == "created"

boarddata-6.6.1/tests/test_risks.py

@@ -0,0 +1,59 @@
+"""Tests for RisksMixin methods."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+
+def make_client():
+    from boarddata._base import Base
+    from boarddata._risks import RisksMixin
+
+    class TestClient(RisksMixin, Base):
+        pass
+
+    client = TestClient.__new__(TestClient)
+    client._request = MagicMock()
+    client._get_token = MagicMock(return_value="fake-token")
+    client.base_url = "https://api.example.com"
+    client.timeout = 30
+    return client
+
+
+class TestBatchCreateRiskSection:
+    def test_posts_envelopes_to_batch_path(self):
+        c = make_client()
+        c._request.return_value = [
+            {"company": "FR0000120271", "section_id": "s1", "factor_count": 12, "action": "loaded"}
+        ]
+        envelopes = [
+            {
+                "company": "FR0000120271",
+                "date_publication": "2025-01-01",
+                "_risk_section": {"section_found": True, "scale_type": "numeric"},
+                "_risk_categories": [{"label_native": "Risques financiers"}],
+                "_risk_factor_items": [{"title_native": "Risque de change"}],
+            }
+        ]
+        result = c.batch_create_risk_section(envelopes)
+        args, kwargs = c._request.call_args
+        assert args == ("POST", "risks/batch/")
+        assert kwargs["json"] is envelopes
+        assert result[0]["action"] == "loaded"
+        assert result[0]["factor_count"] == 12
+
+    def test_passes_section_not_found_envelope_through(self):
+        c = make_client()
+        c._request.return_value = [{"company": "FR0000131104", "action": "loaded"}]
+        envelopes = [
+            {
+                "company": "FR0000131104",
+                "date_publication": "2025-01-01",
+                "_risk_section": {"section_found": False},
+                "_risk_categories": [],
+                "_risk_factor_items": [],
+            }
+        ]
+        c.batch_create_risk_section(envelopes)
+        _, kwargs = c._request.call_args
+        assert kwargs["json"][0]["_risk_section"]["section_found"] is False

{boarddata-6.4.2 → boarddata-6.6.1}/types/__init__.py

@@ -113,6 +113,10 @@ from .persons import (
     SchoolItem,
     UpdatePersonPayload,
 )
+from .risks import (
+    RiskSectionBatchItemPayload,
+    RiskSectionBatchResultItem,
+)
 from .sentinel import (
     AnalysisDetail,
     AnalysisListItem,
@@ -227,6 +231,9 @@ __all__ = [
     "PersonSimilarityItem",
     "SchoolItem",
     "UpdatePersonPayload",
+    # risks
+    "RiskSectionBatchItemPayload",
+    "RiskSectionBatchResultItem",
     # sentinel
     "AnalysisDetail",
     "AnalysisListItem",

boarddata-6.6.1/types/risks.py

@@ -0,0 +1,53 @@
+"""Risk-Factors (Art. 16) batch types.
+
+The risk-section batch envelope is built by the URD extraction pipeline's
+``risk_factors`` adapter. Its nested members (``_risk_section``,
+``_risk_categories``, ``_risk_factor_items``) are issuer-shaped and carry
+free-form fields (e.g. ``quant_metrics``), so they are typed loosely as
+``dict[str, Any]`` rather than fully enumerated here — the authoritative schema
+lives in the extractor contract and the backend loader (``apps/risks``).
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Any
+
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict
+else:
+    from typing_extensions import NotRequired, TypedDict
+
+
+class RiskSectionBatchItemPayload(TypedDict):
+    """One envelope in a ``batch_create_risk_section`` request.
+
+    Matched by the natural key ``(company, date_publication)``; the backend
+    does a delete-and-replace of the section's categories/factors.
+    """
+
+    company: str
+    """Issuer ISIN (the batch endpoint matches Company by isin, not UUID)."""
+    date_publication: str
+    """Publication date, ``"YYYY-MM-DD"``."""
+    _risk_section: dict[str, Any]
+    """Section-level scale/methodology metadata (incl. ``section_found``)."""
+    _risk_categories: list[dict[str, Any]]
+    """Category headings (native + English label)."""
+    _risk_factor_items: list[dict[str, Any]]
+    """Individual risk factors with their native ratings / field sources."""
+
+
+class RiskSectionBatchResultItem(TypedDict):
+    """One result in a ``batch_create_risk_section`` response.
+
+    ``action`` is one of ``"loaded"`` (section upserted),
+    ``"skipped_unknown_company"`` (no Company for the ISIN — seed it first), or
+    ``"error"`` (malformed item; ``detail`` carries the message).
+    """
+
+    company: str
+    action: str
+    section_id: NotRequired[str]
+    factor_count: NotRequired[int]
+    detail: NotRequired[str]