fmp-data 0.0.0__py3-none-any.whl

fmp_data/__init__.py

@@ -0,0 +1,138 @@
+"""
+fmp-data top-level package
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Core usage:
+
+    import fmp_data as fmp
+    client = fmp.FMPDataClient(...)
+
+Optional LangChain / FAISS helpers are exposed lazily and raise
+ImportError with guidance if the extra is not installed.
+"""
+
+from __future__ import annotations
+
+import importlib.util as _importlib_util
+import types as _types
+import warnings as _warnings
+from typing import Any
+
+from fmp_data.client import FMPDataClient
+from fmp_data.config import (
+    ClientConfig,
+    LoggingConfig,
+    LogHandlerConfig,
+    RateLimitConfig,
+)
+from fmp_data.exceptions import (
+    AuthenticationError,
+    ConfigError,
+    FMPError,
+    RateLimitError,
+    ValidationError,
+)
+from fmp_data.logger import FMPLogger
+
+__version__ = "0.0.0"
+
+# --------------------------------------------------------------------------- #
+#  Public re-exports guaranteed to work without optional dependencies
+# --------------------------------------------------------------------------- #
+__all__ = [
+    "FMPDataClient",
+    "ClientConfig",
+    "LoggingConfig",
+    "LogHandlerConfig",
+    "RateLimitConfig",
+    "FMPError",
+    "FMPLogger",
+    "RateLimitError",
+    "AuthenticationError",
+    "ValidationError",
+    "ConfigError",
+    "logger",
+    "is_langchain_available",
+]
+
+logger = FMPLogger()
+
+
+# --------------------------------------------------------------------------- #
+#  Helper: detect whether LangChain core stack is available
+# --------------------------------------------------------------------------- #
+def is_langchain_available() -> bool:
+    """
+    Return ``True`` if the optional *langchain* extra is installed.
+
+    We check for ``langchain_core`` because it is imported by every
+    sub-module that fmp-data’s LC helpers rely on.
+    """
+    return _importlib_util.find_spec("langchain_core") is not None
+
+
+# --------------------------------------------------------------------------- #
+#  Lazy import machinery for optional vector-store helpers
+# --------------------------------------------------------------------------- #
+def _lazy_import_vector_store() -> _types.ModuleType:
+    """
+    Import fmp_data.lc only when a LC-specific symbol is first accessed.
+    Raises ImportError with installation hint if LangChain (or FAISS) is missing.
+    """
+    if not is_langchain_available():
+        raise ImportError(
+            "Optional LangChain features are not installed. "
+            "Run:  pip install 'fmp-data[langchain]'"
+        ) from None
+
+    # Import inside the function to keep top-level import cheap.
+    from fmp_data import lc as _lc  # noqa: WPS433 (allow internal import)
+
+    # Check FAISS at runtime to give a clearer error than module not found.
+    if _importlib_util.find_spec("faiss") is None:
+        raise ImportError(
+            "FAISS is required for vector-store helpers. "
+            "Run:  pip install 'fmp-data[langchain]'"
+        ) from None
+
+    return _lc
+
+
+# Map attribute names to callables that will supply them on demand.
+# Keys must match what you later append to __all__.
+_lazy_attrs = {
+    "EndpointVectorStore": lambda: _lazy_import_vector_store().EndpointVectorStore,
+    "EndpointSemantics": lambda: _lazy_import_vector_store().EndpointSemantics,
+    "SemanticCategory": lambda: _lazy_import_vector_store().SemanticCategory,
+    "create_vector_store": lambda: _lazy_import_vector_store().create_vector_store,
+}
+
+# extend __all__ so IDEs still see the names when LC is installed
+__all__.extend(_lazy_attrs.keys())
+
+
+def __getattr__(name: str) -> Any:  # pragma: no cover
+    """
+    PEP 562 hook: resolve optional symbols at first access.
+
+    If *name* is one of the LC helpers, call the associated factory,
+    cache the result in the module dict, and return it.
+    """
+    if name in _lazy_attrs:
+        value = _lazy_attrs[name]()
+        globals()[name] = value  # cache so subsequent access is fast
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+# --------------------------------------------------------------------------- #
+#  Warn immediately if user tried to import LC helpers without extras
+# --------------------------------------------------------------------------- #
+if not is_langchain_available():
+    _warnings.filterwarnings("once", category=ImportWarning)
+    _warnings.warn(
+        "LangChain extras not installed; vector-store helpers will be unavailable "
+        "until you run:  pip install 'fmp-data[langchain]'",
+        ImportWarning,
+        stacklevel=2,
+    )

fmp_data/alternative/__init__.py

@@ -0,0 +1,34 @@
+# fmp_data/alternative/__init__.py
+from __future__ import annotations
+
+from fmp_data.alternative.client import AlternativeMarketsClient
+from fmp_data.alternative.models import (
+    Commodity,
+    CommodityHistoricalPrice,
+    CommodityIntradayPrice,
+    CommodityQuote,
+    CryptoHistoricalPrice,
+    CryptoIntradayPrice,
+    CryptoPair,
+    CryptoQuote,
+    ForexHistoricalPrice,
+    ForexIntradayPrice,
+    ForexPair,
+    ForexQuote,
+)
+
+__all__ = [
+    "AlternativeMarketsClient",
+    "CryptoPair",
+    "CryptoQuote",
+    "CryptoHistoricalPrice",
+    "CryptoIntradayPrice",
+    "ForexPair",
+    "ForexQuote",
+    "ForexHistoricalPrice",
+    "ForexIntradayPrice",
+    "Commodity",
+    "CommodityQuote",
+    "CommodityHistoricalPrice",
+    "CommodityIntradayPrice",
+]

fmp_data/alternative/client.py

@@ -0,0 +1,150 @@
+# fmp_data/alternative/client.py
+from datetime import date
+from typing import TypeVar, cast
+
+from fmp_data.alternative.endpoints import (
+    COMMODITIES_LIST,
+    COMMODITIES_QUOTES,
+    COMMODITY_HISTORICAL,
+    COMMODITY_INTRADAY,
+    COMMODITY_QUOTE,
+    CRYPTO_HISTORICAL,
+    CRYPTO_INTRADAY,
+    CRYPTO_LIST,
+    CRYPTO_QUOTE,
+    CRYPTO_QUOTES,
+    FOREX_HISTORICAL,
+    FOREX_INTRADAY,
+    FOREX_LIST,
+    FOREX_QUOTE,
+    FOREX_QUOTES,
+)
+from fmp_data.alternative.models import (
+    Commodity,
+    CommodityIntradayPrice,
+    CommodityPriceHistory,
+    CommodityQuote,
+    CryptoHistoricalData,
+    CryptoIntradayPrice,
+    CryptoPair,
+    CryptoQuote,
+    ForexIntradayPrice,
+    ForexPair,
+    ForexPriceHistory,
+    ForexQuote,
+)
+from fmp_data.base import EndpointGroup
+
+T = TypeVar("T")
+
+
+class AlternativeMarketsClient(EndpointGroup):
+    """Client for alternative markets endpoints"""
+
+    # Cryptocurrency methods
+    def get_crypto_list(self) -> list[CryptoPair]:
+        """Get list of available cryptocurrencies"""
+        return self.client.request(CRYPTO_LIST)
+
+    def get_crypto_quotes(self) -> list[CryptoQuote]:
+        """Get cryptocurrency quotes"""
+        return self.client.request(CRYPTO_QUOTES)
+
+    def get_crypto_quote(self, symbol: str) -> CryptoQuote:
+        """Get cryptocurrency quote"""
+        result = self.client.request(CRYPTO_QUOTE, symbol=symbol)
+        return cast(CryptoQuote, result[0] if isinstance(result, list) else result)
+
+    def get_crypto_historical(
+        self,
+        symbol: str,
+        start_date: date | None = None,
+        end_date: date | None = None,
+    ) -> CryptoHistoricalData:
+        """Get cryptocurrency historical prices"""
+        params = {"symbol": symbol}
+        if start_date:
+            params["from"] = start_date.strftime("%Y-%m-%d")
+        if end_date:
+            params["to"] = end_date.strftime("%Y-%m-%d")
+
+        result = self.client.request(CRYPTO_HISTORICAL, **params)
+        return cast(CryptoHistoricalData, result)
+
+    def get_crypto_intraday(
+        self, symbol: str, interval: str = "5min"
+    ) -> list[CryptoIntradayPrice]:
+        """Get cryptocurrency intraday prices"""
+        return self.client.request(CRYPTO_INTRADAY, symbol=symbol, interval=interval)
+
+    # Forex methods
+    def get_forex_list(self) -> list[ForexPair]:
+        """Get list of available forex pairs"""
+        return self.client.request(FOREX_LIST)
+
+    def get_forex_quotes(self) -> list[ForexQuote]:
+        """Get forex quotes"""
+        return self.client.request(FOREX_QUOTES)
+
+    def get_forex_quote(self, symbol: str) -> ForexQuote:
+        """Get forex quote"""
+        result = self.client.request(FOREX_QUOTE, symbol=symbol)
+        return cast(ForexQuote, result[0] if isinstance(result, list) else result)
+
+    def get_forex_historical(
+        self,
+        symbol: str,
+        start_date: date | None = None,
+        end_date: date | None = None,
+    ) -> ForexPriceHistory:
+        """Get forex historical prices"""
+        params = {"symbol": symbol}
+        if start_date:
+            params["from"] = start_date.strftime("%Y-%m-%d")
+        if end_date:
+            params["to"] = end_date.strftime("%Y-%m-%d")
+
+        result = self.client.request(FOREX_HISTORICAL, **params)
+        return cast(ForexPriceHistory, result)
+
+    def get_forex_intraday(
+        self, symbol: str, interval: str = "5min"
+    ) -> list[ForexIntradayPrice]:
+        """Get forex intraday prices"""
+        return self.client.request(FOREX_INTRADAY, symbol=symbol, interval=interval)
+
+    # Commodities methods
+    def get_commodities_list(self) -> list[Commodity]:
+        """Get list of available commodities"""
+        return self.client.request(COMMODITIES_LIST)
+
+    def get_commodities_quotes(self) -> list[CommodityQuote]:
+        """Get commodities quotes"""
+        return self.client.request(COMMODITIES_QUOTES)
+
+    def get_commodity_quote(self, symbol: str) -> CommodityQuote:
+        """Get commodity quote"""
+        result = self.client.request(COMMODITY_QUOTE, symbol=symbol)
+        return cast(CommodityQuote, result[0] if isinstance(result, list) else result)
+
+    def get_commodity_historical(
+        self,
+        symbol: str,
+        start_date: date | None = None,
+        end_date: date | None = None,
+    ) -> CommodityPriceHistory:
+        """Get commodity historical prices"""
+        params = {"symbol": symbol}
+        if start_date:
+            params["from"] = start_date.strftime("%Y-%m-%d")
+        if end_date:
+            params["to"] = end_date.strftime("%Y-%m-%d")
+
+        result = self.client.request(COMMODITY_HISTORICAL, **params)
+        return cast(CommodityPriceHistory, result)
+
+    def get_commodity_intraday(
+        self, symbol: str, interval: str = "5min"
+    ) -> list[CommodityIntradayPrice]:
+        """Get commodity intraday prices"""
+        return self.client.request(COMMODITY_INTRADAY, symbol=symbol, interval=interval)