avanza-mcp 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

avanza_mcp/services/market_data_service.py

@@ -4,6 +4,32 @@ from typing import Any
 
 from ..client.base import AvanzaClient
 from ..client.endpoints import PublicEndpoint
+from ..models.certificate import (
+    CertificateDetails,
+    CertificateFilterRequest,
+    CertificateFilterResponse,
+    CertificateInfo,
+)
+from ..models.chart import ChartData
+from ..models.etf import (
+    ETFDetails,
+    ETFFilterRequest,
+    ETFFilterResponse,
+    ETFInfo,
+)
+from ..models.future_forward import (
+    FutureForwardDetails,
+    FutureForwardInfo,
+    FutureForwardMatrixRequest,
+    FutureForwardMatrixResponse,
+)
+from ..models.instrument_data import NumberOfOwners, ShortSellingData
+from ..models.warrant import (
+    WarrantDetails,
+    WarrantFilterRequest,
+    WarrantFilterResponse,
+    WarrantInfo,
+)
 from ..models.fund import (
     FundChart,
     FundChartPeriod,
@@ -296,3 +322,290 @@ class MarketDataService:
         raw_data = await self._client.get(endpoint)
         return FundDescription.model_validate(raw_data)
 
+    # === Certificates ===
+
+    async def filter_certificates(
+        self, filter_request: CertificateFilterRequest
+    ) -> CertificateFilterResponse:
+        """Filter and list certificates with pagination.
+
+        Args:
+            filter_request: Filter criteria and pagination parameters
+
+        Returns:
+            Filtered list of certificates
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.CERTIFICATE_FILTER.value
+        raw_data = await self._client.post(
+            endpoint, json=filter_request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return CertificateFilterResponse.model_validate(raw_data)
+
+    async def get_certificate_info(self, instrument_id: str) -> CertificateInfo:
+        """Fetch detailed certificate information.
+
+        Args:
+            instrument_id: Avanza certificate ID
+
+        Returns:
+            Detailed certificate information
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.CERTIFICATE_INFO.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return CertificateInfo.model_validate(raw_data)
+
+    async def get_certificate_details(self, instrument_id: str) -> CertificateDetails:
+        """Fetch extended certificate details.
+
+        Args:
+            instrument_id: Avanza certificate ID
+
+        Returns:
+            Extended certificate details
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.CERTIFICATE_DETAILS.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return CertificateDetails.model_validate(raw_data)
+
+    # === Warrants ===
+
+    async def filter_warrants(
+        self, filter_request: WarrantFilterRequest
+    ) -> WarrantFilterResponse:
+        """Filter and list warrants with pagination.
+
+        Args:
+            filter_request: Filter criteria and pagination parameters
+
+        Returns:
+            Filtered list of warrants
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.WARRANT_FILTER.value
+        raw_data = await self._client.post(
+            endpoint, json=filter_request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return WarrantFilterResponse.model_validate(raw_data)
+
+    async def get_warrant_info(self, instrument_id: str) -> WarrantInfo:
+        """Fetch detailed warrant information.
+
+        Args:
+            instrument_id: Avanza warrant ID
+
+        Returns:
+            Detailed warrant information
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.WARRANT_INFO.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return WarrantInfo.model_validate(raw_data)
+
+    async def get_warrant_details(self, instrument_id: str) -> WarrantDetails:
+        """Fetch extended warrant details.
+
+        Args:
+            instrument_id: Avanza warrant ID
+
+        Returns:
+            Extended warrant details
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.WARRANT_DETAILS.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return WarrantDetails.model_validate(raw_data)
+
+    # === ETFs ===
+
+    async def filter_etfs(self, filter_request: ETFFilterRequest) -> ETFFilterResponse:
+        """Filter and list ETFs with pagination.
+
+        Args:
+            filter_request: Filter criteria and pagination parameters
+
+        Returns:
+            Filtered list of ETFs
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.ETF_FILTER.value
+        raw_data = await self._client.post(
+            endpoint, json=filter_request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return ETFFilterResponse.model_validate(raw_data)
+
+    async def get_etf_info(self, instrument_id: str) -> ETFInfo:
+        """Fetch detailed ETF information.
+
+        Args:
+            instrument_id: Avanza ETF ID
+
+        Returns:
+            Detailed ETF information
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.ETF_INFO.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return ETFInfo.model_validate(raw_data)
+
+    async def get_etf_details(self, instrument_id: str) -> ETFDetails:
+        """Fetch extended ETF details.
+
+        Args:
+            instrument_id: Avanza ETF ID
+
+        Returns:
+            Extended ETF details
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.ETF_DETAILS.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return ETFDetails.model_validate(raw_data)
+
+    # === Futures/Forwards ===
+
+    async def list_futures_forwards(
+        self, request: FutureForwardMatrixRequest
+    ) -> FutureForwardMatrixResponse:
+        """List futures and forwards using matrix endpoint.
+
+        Args:
+            request: Matrix list request parameters
+
+        Returns:
+            Matrix response with futures/forwards
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.FUTURE_FORWARD_MATRIX.value
+        raw_data = await self._client.post(
+            endpoint, json=request.model_dump(by_alias=True, exclude_none=True)
+        )
+        return FutureForwardMatrixResponse.model_validate(raw_data)
+
+    async def get_future_forward_info(self, instrument_id: str) -> FutureForwardInfo:
+        """Fetch detailed future/forward information.
+
+        Args:
+            instrument_id: Avanza future/forward ID
+
+        Returns:
+            Detailed future/forward information
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.FUTURE_FORWARD_INFO.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return FutureForwardInfo.model_validate(raw_data)
+
+    async def get_future_forward_details(
+        self, instrument_id: str
+    ) -> FutureForwardDetails:
+        """Fetch extended future/forward details.
+
+        Args:
+            instrument_id: Avanza future/forward ID
+
+        Returns:
+            Extended future/forward details
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.FUTURE_FORWARD_DETAILS.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return FutureForwardDetails.model_validate(raw_data)
+
+    async def get_future_forward_filter_options(self) -> dict[str, Any]:
+        """Get available filter options for futures/forwards.
+
+        Returns:
+            Available filter options including underlying instruments, dates, etc.
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.FUTURE_FORWARD_FILTER_OPTIONS.value
+        raw_data = await self._client.get(endpoint)
+        return raw_data
+
+    # === Additional Features ===
+
+    async def get_number_of_owners(self, instrument_id: str) -> NumberOfOwners:
+        """Get number of owners for an instrument.
+
+        Args:
+            instrument_id: Avanza instrument ID
+
+        Returns:
+            Number of owners data
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.NUMBER_OF_OWNERS.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return NumberOfOwners.model_validate(raw_data)
+
+    async def get_short_selling(self, instrument_id: str) -> ShortSellingData:
+        """Get short selling data for an instrument.
+
+        Args:
+            instrument_id: Avanza instrument ID
+
+        Returns:
+            Short selling data
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.SHORT_SELLING.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint)
+        return ShortSellingData.model_validate(raw_data)
+
+    async def get_marketmaker_chart(
+        self, instrument_id: str, time_period: str = "today"
+    ) -> ChartData:
+        """Get price chart data for traded products (certificates, warrants, ETFs).
+
+        This endpoint provides OHLC (Open-High-Low-Close) candlestick data
+        with market maker information for traded products.
+
+        Args:
+            instrument_id: Avanza instrument ID
+            time_period: Time period for chart data (default: "today")
+                Available periods: today, one_week, one_month, three_months,
+                six_months, one_year, three_years, five_years, etc.
+
+        Returns:
+            Chart data with OHLC candlesticks and metadata
+
+        Raises:
+            AvanzaError: If request fails
+        """
+        endpoint = PublicEndpoint.MARKETMAKER_CHART.format(id=instrument_id)
+        raw_data = await self._client.get(endpoint, params={"timePeriod": time_period})
+        return ChartData.model_validate(raw_data)
+

avanza_mcp/tools/__init__.py

@@ -1,8 +1,22 @@
 """MCP tools for Avanza API."""
 
 # Import to register tools via decorators
+from . import certificates  # noqa: F401
+from . import etfs  # noqa: F401
 from . import funds  # noqa: F401
+from . import futures_forwards  # noqa: F401
+from . import instrument_data  # noqa: F401
 from . import market_data  # noqa: F401
 from . import search  # noqa: F401
+from . import warrants  # noqa: F401
 
-__all__ = ["search", "market_data", "funds"]
+__all__ = [
+    "certificates",
+    "etfs",
+    "funds",
+    "futures_forwards",
+    "instrument_data",
+    "market_data",
+    "search",
+    "warrants",
+]

avanza_mcp/tools/certificates.py

@@ -0,0 +1,156 @@
+"""Certificate MCP tools."""
+
+from fastmcp import Context
+
+from .. import mcp
+from ..client import AvanzaClient
+from ..models.certificate import CertificateFilter, CertificateFilterRequest
+from ..models.filter import SortBy
+from ..services import MarketDataService
+
+
+@mcp.tool()
+async def filter_certificates(
+    ctx: Context,
+    offset: int = 0,
+    limit: int = 20,
+    directions: list[str] | None = None,
+    leverages: list[float] | None = None,
+    issuers: list[str] | None = None,
+    categories: list[str] | None = None,
+    exposures: list[str] | None = None,
+    underlying_instruments: list[str] | None = None,
+    sort_field: str = "name",
+    sort_order: str = "asc",
+) -> dict:
+    """Filter and list certificates with optional filtering and pagination.
+
+    Search through available certificates with optional filters for direction
+    (long/short), leverage, issuer, category, exposure, and underlying instrument.
+    Supports pagination for large result sets.
+
+    Args:
+        ctx: MCP context for logging
+        offset: Number of results to skip (default: 0)
+        limit: Maximum number of results to return (default: 20, max: 100)
+        directions: Filter by direction, e.g., ["long"], ["short"]
+        leverages: Filter by leverage values, e.g., [1.0, 2.0]
+        issuers: Filter by issuer names, e.g., ["Valour", "21Shares"]
+        categories: Filter by categories
+        exposures: Filter by exposures
+        underlying_instruments: Filter by underlying instrument IDs
+        sort_field: Field to sort by (default: "name")
+        sort_order: Sort order "asc" or "desc" (default: "asc")
+
+    Returns:
+        Filtered list of certificates with:
+        - certificates: Array of certificate objects with orderbookId, name, price, etc.
+        - pagination: Current offset and limit
+        - totalNumberOfOrderbooks: Total matching certificates
+
+    Examples:
+        List first 20 certificates:
+        >>> filter_certificates()
+
+        Find long certificates with 1x leverage:
+        >>> filter_certificates(directions=["long"], leverages=[1.0])
+
+        Get next page of results:
+        >>> filter_certificates(offset=20, limit=20)
+    """
+    ctx.info(f"Filtering certificates: offset={offset}, limit={limit}")
+
+    try:
+        filter_req = CertificateFilterRequest(
+            filter=CertificateFilter(
+                directions=directions or [],
+                leverages=leverages or [],
+                issuers=issuers or [],
+                categories=categories or [],
+                exposures=exposures or [],
+                underlyingInstruments=underlying_instruments or [],
+            ),
+            offset=offset,
+            limit=min(limit, 100),
+            sortBy=SortBy(field=sort_field, order=sort_order),
+        )
+
+        async with AvanzaClient() as client:
+            service = MarketDataService(client)
+            result = await service.filter_certificates(filter_req)
+
+        ctx.info(f"Retrieved {len(result.certificates)} certificates")
+        return result.model_dump(by_alias=True, exclude_none=True)
+
+    except Exception as e:
+        ctx.error(f"Failed to filter certificates: {str(e)}")
+        raise
+
+
+@mcp.tool()
+async def get_certificate_info(ctx: Context, instrument_id: str) -> dict:
+    """Get detailed information about a specific certificate.
+
+    Provides comprehensive certificate data including current price, leverage,
+    underlying instrument, issuer, and historical performance.
+
+    Args:
+        ctx: MCP context for logging
+        instrument_id: Avanza certificate ID (orderbookId from filter results)
+
+    Returns:
+        Detailed certificate information including:
+        - Basic info: name, ISIN, issuer
+        - Pricing: current quote, buy/sell prices
+        - Characteristics: leverage, direction, underlying instrument
+        - Historical data: price history over various periods
+
+    Examples:
+        Get info for a certificate:
+        >>> get_certificate_info(instrument_id="1756318")
+    """
+    ctx.info(f"Fetching certificate info for ID: {instrument_id}")
+
+    try:
+        async with AvanzaClient() as client:
+            service = MarketDataService(client)
+            certificate = await service.get_certificate_info(instrument_id)
+
+        ctx.info(f"Retrieved info for: {certificate.name}")
+        return certificate.model_dump(by_alias=True, exclude_none=True)
+
+    except Exception as e:
+        ctx.error(f"Failed to fetch certificate info: {str(e)}")
+        raise
+
+
+@mcp.tool()
+async def get_certificate_details(ctx: Context, instrument_id: str) -> dict:
+    """Get extended details about a specific certificate.
+
+    Provides additional detailed information beyond basic certificate info.
+
+    Args:
+        ctx: MCP context for logging
+        instrument_id: Avanza certificate ID
+
+    Returns:
+        Extended certificate details
+
+    Examples:
+        Get detailed info:
+        >>> get_certificate_details(instrument_id="1756318")
+    """
+    ctx.info(f"Fetching certificate details for ID: {instrument_id}")
+
+    try:
+        async with AvanzaClient() as client:
+            service = MarketDataService(client)
+            details = await service.get_certificate_details(instrument_id)
+
+        ctx.info("Retrieved certificate details")
+        return details.model_dump(by_alias=True, exclude_none=True)
+
+    except Exception as e:
+        ctx.error(f"Failed to fetch certificate details: {str(e)}")
+        raise

avanza_mcp/tools/etfs.py

@@ -0,0 +1,151 @@
+"""ETF MCP tools."""
+
+from fastmcp import Context
+
+from .. import mcp
+from ..client import AvanzaClient
+from ..models.etf import ETFFilter, ETFFilterRequest
+from ..models.filter import SortBy
+from ..services import MarketDataService
+
+
+@mcp.tool()
+async def filter_etfs(
+    ctx: Context,
+    offset: int = 0,
+    limit: int = 20,
+    asset_categories: list[str] | None = None,
+    sub_categories: list[str] | None = None,
+    exposures: list[str] | None = None,
+    risk_scores: list[str] | None = None,
+    directions: list[str] | None = None,
+    issuers: list[str] | None = None,
+    currency_codes: list[str] | None = None,
+    sort_field: str = "numberOfOwners",
+    sort_order: str = "desc",
+) -> dict:
+    """Filter and list ETFs with optional filtering and pagination.
+
+    Search through exchange-traded funds with filters for asset category,
+    geographic exposure, issuer, risk score, and more.
+
+    Args:
+        ctx: MCP context for logging
+        offset: Number of results to skip (default: 0)
+        limit: Maximum number of results (default: 20, max: 100)
+        asset_categories: Filter by category, e.g., ["stock"], ["commodity"]
+        sub_categories: Filter by sub-category, e.g., ["teknologi"], ["fastigheter"]
+        exposures: Filter by geographic exposure, e.g., ["usa"], ["global"]
+        risk_scores: Filter by risk score levels
+        directions: Filter by direction (for leveraged ETFs)
+        issuers: Filter by issuer, e.g., ["iShares"], ["Vanguard"]
+        currency_codes: Filter by currency, e.g., ["SEK"], ["USD"]
+        sort_field: Field to sort by (default: "numberOfOwners")
+        sort_order: Sort order "asc" or "desc" (default: "desc")
+
+    Returns:
+        Filtered list of ETFs with fees, yield, number of owners, etc.
+
+    Examples:
+        List most popular ETFs:
+        >>> filter_etfs(sort_field="numberOfOwners", sort_order="desc")
+
+        Find US technology ETFs:
+        >>> filter_etfs(exposures=["usa"], sub_categories=["teknologi"])
+
+        Get affordable ETFs with low fees:
+        >>> filter_etfs(sort_field="managementFee", sort_order="asc")
+    """
+    ctx.info(f"Filtering ETFs: offset={offset}, limit={limit}")
+
+    try:
+        filter_req = ETFFilterRequest(
+            filter=ETFFilter(
+                assetCategories=asset_categories or [],
+                subCategories=sub_categories or [],
+                exposures=exposures or [],
+                riskScores=risk_scores or [],
+                directions=directions or [],
+                issuers=issuers or [],
+                currencyCodes=currency_codes or [],
+            ),
+            offset=offset,
+            limit=min(limit, 100),
+            sortBy=SortBy(field=sort_field, order=sort_order),
+        )
+
+        async with AvanzaClient() as client:
+            service = MarketDataService(client)
+            result = await service.filter_etfs(filter_req)
+
+        ctx.info(f"Retrieved {len(result.etfs)} ETFs")
+        return result.model_dump(by_alias=True, exclude_none=True)
+
+    except Exception as e:
+        ctx.error(f"Failed to filter ETFs: {str(e)}")
+        raise
+
+
+@mcp.tool()
+async def get_etf_info(ctx: Context, instrument_id: str) -> dict:
+    """Get detailed information about a specific ETF.
+
+    Provides comprehensive ETF data including current NAV, dividend yield,
+    management fees, risk score, and historical performance.
+
+    Args:
+        ctx: MCP context for logging
+        instrument_id: Avanza ETF ID
+
+    Returns:
+        Detailed ETF information with fees, yield, performance, etc.
+
+    Examples:
+        Get ETF info:
+        >>> get_etf_info(instrument_id="742236")
+    """
+    ctx.info(f"Fetching ETF info for ID: {instrument_id}")
+
+    try:
+        async with AvanzaClient() as client:
+            service = MarketDataService(client)
+            etf = await service.get_etf_info(instrument_id)
+
+        ctx.info(f"Retrieved info for: {etf.name}")
+        return etf.model_dump(by_alias=True, exclude_none=True)
+
+    except Exception as e:
+        ctx.error(f"Failed to fetch ETF info: {str(e)}")
+        raise
+
+
+@mcp.tool()
+async def get_etf_details(ctx: Context, instrument_id: str) -> dict:
+    """Get extended details about a specific ETF.
+
+    Provides additional detailed information beyond basic ETF info.
+
+    Args:
+        ctx: MCP context for logging
+        instrument_id: Avanza ETF ID
+
+    Returns:
+        Extended ETF details
+
+    Examples:
+        Get detailed info:
+        >>> get_etf_details(instrument_id="742236")
+    """
+    ctx.info(f"Fetching ETF details for ID: {instrument_id}")
+
+    try:
+        async with AvanzaClient() as client:
+            service = MarketDataService(client)
+            details = await service.get_etf_details(instrument_id)
+
+        ctx.info("Retrieved ETF details")
+        return details.model_dump(by_alias=True, exclude_none=True)
+
+    except Exception as e:
+        ctx.error(f"Failed to fetch ETF details: {str(e)}")
+        raise